Metrics for math.log/2 on complex, real part

start0.0ms (0%)

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

analyze176.0ms (3%)

Memory

-12.5MiB live, 272.1MiB allocated; 67ms 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%	49.9%	0.1%	0%	49.9%	0%	4
0%	0%	49.9%	0.1%	0%	49.9%	0%	5
0%	0%	49.9%	0.1%	0%	49.9%	0%	6
9.4%	4.7%	45.2%	0.1%	0%	49.9%	0%	7
17.2%	8.6%	41.3%	0.1%	0%	49.9%	0%	8
27.3%	13.7%	36.3%	0.1%	0%	49.9%	0%	9
41%	20.5%	29.4%	0.1%	0%	49.9%	0%	10
48.6%	24.3%	25.6%	0.1%	0%	49.9%	0%	11
57.1%	28.5%	21.4%	0.1%	0%	49.9%	0%	12

Compiler

Compiled 30 to 17 computations (43.3% saved)

sample1.5s (26.4%)

Memory

22.5MiB live, 1 711.2MiB allocated; 344ms collecting garbage

Samples

1.2s	8 255×	0	valid
0.0ms	1×	1	valid

Precisions

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

ival-mult!: 240.0ms (26.8% of total)

ival-hypot: 205.0ms (22.9% of total)

ival-log: 192.0ms (21.5% of total)

ival-atan2: 129.0ms (14.4% of total)

ival-div!: 77.0ms (8.6% of total)

ival-add!: 51.0ms (5.7% of total)

adjust: 2.0ms (0.2% of total)

Bogosity

explain245.0ms (4.2%)

Memory

33.5MiB live, 571.1MiB allocated; 65ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
134	-	4	(-1.0341904474913285e-157 -2.5547175748067263e-226 7.386064153182362e-186)	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	0	-	`(log.f64 base)`
0	-	0	-	`(*.f64 re re)`
0	-	0	-	`(atan2.f64 im re)`
0	-	0	-	`im`
0	-	0	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	0	-	`re`
0	-	0	-	`(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))`
0	-	0	-	`(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))`
0	-	0	-	`(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))`
0	-	0	-	`#s(literal 0 binary64)`
0	-	0	-	`(*.f64 (atan2.f64 im re) #s(literal 0 binary64))`
0	-	0	-	`(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))`
0	-	0	-	`(*.f64 (log.f64 base) (log.f64 base))`
0	-	0	-	`(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))`
0	-	0	-	`(*.f64 im im)`
0	-	0	-	`base`
0	-	0	-	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`

Explanations

Click to see full explanations table

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

Confusion

	Predicted +	Predicted -
+	130	2
-	0	124

Precision

1.0

Recall

0.9848484848484849

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	130	0	2
-	0	0	124

Precision?

1.0

Recall?

0.9848484848484849

Freqs

test

number	freq
0	126
1	130

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

79.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

ival-mult!: 21.0ms (37.9% of total)

ival-hypot: 14.0ms (25.3% of total)

ival-log: 11.0ms (19.9% of total)

ival-atan2: 4.0ms (7.2% of total)

ival-add!: 3.0ms (5.4% of total)

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

adjust: 0.0ms (0% of total)

preprocess57.0ms (1%)

Memory

-34.2MiB live, 57.3MiB allocated; 10ms collecting garbage

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	79	209
1	236	189
2	1254	142

Stop Event

1×	node-limit

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	50.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Status

Accuracy

Program

▶

50.3%

(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 56 to 36 computations (35.7% saved)

series151.0ms (2.6%)

Memory

1.2MiB live, 237.2MiB allocated; 33ms collecting garbage

Counts

18 → 148

Calls

Call 1

Inputs
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
(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 base)
base
(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
(atan2.f64 im re)
#s(literal 0 binary64)
(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))

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

Calls

9 calls:

Time	Variable		Point	Expression
89.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
21.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
14.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
4.0ms	re	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
3.0ms	im	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))

rewrite250.0ms (4.3%)

Memory

49.7MiB live, 235.9MiB allocated; 19ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	541	5513
0	566	4927
1	2887	4895
0	8237	3971

Stop Event

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

Counts

166 → 383

Calls

Call 1

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

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

eval46.0ms (0.8%)

Memory: -25.6MiB live, 107.7MiB allocated; 14ms collecting garbage
Compiler: Compiled 12 415 to 1 734 computations (86% saved)

prune12.0ms (0.2%)

Memory

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

Pruning

11 alts after pruning (11 fresh and 0 done)

	Pruned	Kept	Total
New	331	11	342
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	332	11	343

Accuracy

99.8%

Counts

343 → 11

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.1%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.2%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.0%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	50.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
	50.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
▶	50.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	26.6%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	26.6%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	99.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
	10.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
▶	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 700 to 456 computations (34.9% saved)

series299.0ms (5.1%)

Memory

-31.9MiB live, 494.5MiB allocated; 69ms collecting garbage

Counts

41 → 415

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
72.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0)) (* (/ 1 (pow (log base) -1)) (log base)) (/ 1 (pow (log base) -1)) (pow (log base) -1) -1)
49.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0)) (* (/ 1 (pow (log base) -1)) (log base)) (/ 1 (pow (log base) -1)) (pow (log base) -1) -1)
44.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0)) (* (/ 1 (pow (log base) -1)) (log base)) (/ 1 (pow (log base) -1)) (pow (log base) -1) -1)
42.0ms	re	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0)) (* (/ 1 (pow (log base) -1)) (log base)) (/ 1 (pow (log base) -1)) (pow (log base) -1) -1)
41.0ms	im	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0)) (* (/ 1 (pow (log base) -1)) (log base)) (/ 1 (pow (log base) -1)) (pow (log base) -1) -1)

rewrite214.0ms (3.7%)

Memory

42.4MiB live, 276.1MiB allocated; 17ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	856	16075
0	922	12205
1	3393	12093
0	9035	11654

Stop Event

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

Counts

456 → 1 021

Calls

Call 1

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

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

eval1.1s (19.1%)

Memory: -62.7MiB live, 225.3MiB allocated; 1.6s collecting garbage
Compiler: Compiled 25 952 to 2 716 computations (89.5% saved)

prune50.0ms (0.9%)

Memory

-102.3MiB live, 32.6MiB allocated; 13ms collecting garbage

Pruning

25 alts after pruning (23 fresh and 2 done)

	Pruned	Kept	Total
New	700	22	722
Fresh	5	1	6
Picked	3	2	5
Done	0	0	0
Total	708	25	733

Accuracy

99.9%

Counts

733 → 25

Alt Table

Click to see full alt table

Status	Accuracy	Program
	53.6%	(/.f64 (fma.f64 (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.1%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(/.f64 (fma.f64 (neg.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.0%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
	98.9%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64)))
	99.1%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
	99.1%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	44.1%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	53.1%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
▶	53.7%	(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.0%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.2%	(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	10.2%	(/.f64 #s(approx (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (*.f64 (log.f64 re) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	98.7%	(/.f64 #s(approx (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (*.f64 (log.f64 im) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	10.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
▶	99.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))))
	53.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
▶	54.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))))
✓	99.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
▶	53.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (exp.f64 (log.f64 (log.f64 base)))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (log.f64 base)))
	53.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
✓	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
	53.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base)))))

Compiler

Compiled 1 414 to 951 computations (32.7% saved)

series214.0ms (3.7%)

Memory

21.3MiB live, 390.4MiB allocated; 51ms collecting garbage

Counts

29 → 273

Calls

Call 1

Inputs
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))))
(/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64)))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (log.f64 base) #s(literal -1 binary64))
(log.f64 base)
base
#s(literal -1 binary64)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
(/.f64 (log.f64 re) (log.f64 base))
(log.f64 re)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (exp.f64 (log.f64 (log.f64 base)))))
(/.f64 (log.f64 (hypot.f64 im re)) (exp.f64 (log.f64 (log.f64 base))))
(exp.f64 (log.f64 (log.f64 base)))
(log.f64 (log.f64 base))
(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64))
#s(literal 0 binary64)
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))))
(/.f64 (log.f64 (hypot.f64 im re)) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64))))
(*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64))
(pow.f64 (log.f64 base) #s(literal -1/2 binary64))
#s(literal -1/2 binary64)

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

Calls

9 calls:

Time	Variable		Point	Expression
83.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1) -1)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (pow (pow (log base) -1) -1) (pow (log base) -1) (log base) base -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1)) (pow (pow (log base) -1/2) -1) (pow (log base) -1/2) -1/2)
36.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1) -1)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (pow (pow (log base) -1) -1) (pow (log base) -1) (log base) base -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1)) (pow (pow (log base) -1/2) -1) (pow (log base) -1/2) -1/2)
31.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1) -1)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (pow (pow (log base) -1) -1) (pow (log base) -1) (log base) base -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1)) (pow (pow (log base) -1/2) -1) (pow (log base) -1/2) -1/2)
24.0ms	re	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1) -1)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (pow (pow (log base) -1) -1) (pow (log base) -1) (log base) base -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1)) (pow (pow (log base) -1/2) -1) (pow (log base) -1/2) -1/2)
14.0ms	re	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1) -1)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (pow (pow (log base) -1) -1) (pow (log base) -1) (log base) base -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (log (log base)))) (exp (log (log base))) (log (log base)) (/ (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) (pow (log base) 2)) (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1))) (* (pow (pow (log base) -1/2) -1) (pow (pow (log base) -1/2) -1)) (pow (pow (log base) -1/2) -1) (pow (log base) -1/2) -1/2)

rewrite277.0ms (4.8%)

Memory

17.9MiB live, 252.8MiB allocated; 70ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	711	10477
0	752	8368
1	3193	8040
0	9097	7780

Stop Event

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

Counts

302 → 632

Calls

Call 1

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

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

eval72.0ms (1.2%)

Memory: -4.9MiB live, 186.2MiB allocated; 20ms collecting garbage
Compiler: Compiled 36 021 to 2 555 computations (92.9% saved)

prune35.0ms (0.6%)

Memory

1.6MiB live, 101.4MiB allocated; 7ms collecting garbage

Pruning

32 alts after pruning (28 fresh and 4 done)

	Pruned	Kept	Total
New	786	18	804
Fresh	8	10	18
Picked	3	2	5
Done	0	2	2
Total	797	32	829

Accuracy

100.0%

Counts

829 → 32

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.1%	(/.f64 (fma.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(/.f64 (fma.f64 (neg.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.0%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
	98.9%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64)))
	99.1%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
	99.1%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
▶	44.1%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	53.6%	(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -4 binary64)))
	53.7%	(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 4 binary64)))
	53.4%	(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.0%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) #s(literal 0 binary64))))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
▶	99.2%	(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	10.2%	(/.f64 #s(approx (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) (*.f64 (log.f64 re) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	98.7%	(/.f64 #s(approx (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) (*.f64 (log.f64 im) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	10.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
	54.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (/.f64 (log.f64 (hypot.f64 im re)) (sqrt.f64 (log.f64 base))) (sqrt.f64 (log.f64 base))))
	54.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64))))
▶	54.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
	54.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 2 binary64))))
	53.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
	53.8%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/4 binary64)) #s(literal -2 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/4 binary64)) #s(literal -2 binary64)))))
✓	99.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
✓	53.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (exp.f64 (log.f64 (log.f64 base)))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (exp.f64 (log.f64 (log.f64 base)))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))))
▶	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (exp.f64 (log.f64 (log.f64 base)))))
	5.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)) (exp.f64 (log.f64 (log.f64 base)))))
	53.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) (exp.f64 (log.f64 (log.f64 base)))))
▶	53.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
✓	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 1 986 to 1 302 computations (34.4% saved)

series383.0ms (6.6%)

Memory

5.9MiB live, 658.0MiB allocated; 85ms collecting garbage

Counts

35 → 277

Calls

Call 1

Inputs
(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re
(log.f64 base)
base
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (log.f64 base)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (log.f64 base))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))
(neg.f64 im)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
(/.f64 (log.f64 im) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base))))
(log.f64 im)
(pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))
(exp.f64 #s(literal 1 binary64))
#s(literal 1 binary64)
(log.f64 (log.f64 base))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
(/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64)))
(pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))
(pow.f64 (log.f64 base) #s(literal -1/2 binary64))
#s(literal -1/2 binary64)
#s(literal -2 binary64)
(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64))
#s(literal 0 binary64)
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))
(log.f64 (neg.f64 (log.f64 base)))
(neg.f64 (log.f64 base))

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

Calls

9 calls:

Time	Variable		Point	Expression
123.0ms	base	@	0	((/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (pow (exp 1) (log (log base)))) (log im) (pow (exp 1) (log (log base))) (exp 1) 1 (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1/2) -2)) (pow (pow (log base) -1/2) -2) (pow (log base) -1/2) -1/2 -2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (exp (* (log (neg (log base))) 2))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)))
76.0ms	base	@	inf	((/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (pow (exp 1) (log (log base)))) (log im) (pow (exp 1) (log (log base))) (exp 1) 1 (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1/2) -2)) (pow (pow (log base) -1/2) -2) (pow (log base) -1/2) -1/2 -2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (exp (* (log (neg (log base))) 2))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)))
74.0ms	base	@	-inf	((/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (pow (exp 1) (log (log base)))) (log im) (pow (exp 1) (log (log base))) (exp 1) 1 (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1/2) -2)) (pow (pow (log base) -1/2) -2) (pow (log base) -1/2) -1/2 -2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (exp (* (log (neg (log base))) 2))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)))
39.0ms	im	@	0	((/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (pow (exp 1) (log (log base)))) (log im) (pow (exp 1) (log (log base))) (exp 1) 1 (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1/2) -2)) (pow (pow (log base) -1/2) -2) (pow (log base) -1/2) -1/2 -2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (exp (* (log (neg (log base))) 2))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)))
31.0ms	im	@	inf	((/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (pow (log base) 2)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (pow (exp 1) (log (log base)))) (log im) (pow (exp 1) (log (log base))) (exp 1) 1 (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (pow (log base) -1/2) -2)) (pow (pow (log base) -1/2) -2) (pow (log base) -1/2) -1/2 -2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (exp (* (log (neg (log base))) 2))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) 0 (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)))

rewrite262.0ms (4.5%)

Memory

34.7MiB live, 361.4MiB allocated; 47ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	726	9638
0	774	8273
1	3205	8152
0	8994	7884

Stop Event

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

Counts

312 → 611

Calls

Call 1

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

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

eval118.0ms (2%)

Memory: -12.5MiB live, 182.8MiB allocated; 38ms collecting garbage
Compiler: Compiled 24 555 to 2 409 computations (90.2% saved)

prune43.0ms (0.7%)

Memory

-12.0MiB live, 128.7MiB allocated; 12ms collecting garbage

Pruning

36 alts after pruning (30 fresh and 6 done)

	Pruned	Kept	Total
New	709	17	726
Fresh	10	13	23
Picked	3	2	5
Done	0	4	4
Total	722	36	758

Accuracy

100.0%

Counts

758 → 36

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.1%	(/.f64 (fma.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(/.f64 (fma.f64 (neg.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.0%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
	53.4%	(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	54.0%	(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	99.2%	(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.1%	(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
	99.1%	(/.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	97.2%	(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
	0.0%	(/.f64 (.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) (neg.f64 re))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	10.2%	(/.f64 (.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	98.7%	(/.f64 (.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.2%	(*.f64 (log.f64 (hypot.f64 re im)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
✓	10.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
	54.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (/.f64 (log.f64 (hypot.f64 im re)) (sqrt.f64 (log.f64 base))) (sqrt.f64 (log.f64 base))))
	54.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64))))
	54.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (sqrt.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -2 binary64))))
	54.2%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 2 binary64))))
	53.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
	53.8%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/4 binary64)) #s(literal -2 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/4 binary64)) #s(literal -2 binary64)))))
✓	99.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
✓	53.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (exp.f64 (log.f64 (log.f64 base)))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (exp.f64 (log.f64 (log.f64 base)))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 2 binary64))))
✓	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (exp.f64 (log.f64 (log.f64 base)))))
	5.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
	5.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)) (exp.f64 (log.f64 (log.f64 base)))))
	53.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
	53.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) (exp.f64 (log.f64 (log.f64 base)))))
	53.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (E.f64) (log.f64 (log.f64 base)))))
✓	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 3 425 to 1 079 computations (68.5% saved)

regimes147.0ms (2.5%)

Memory

20.9MiB live, 251.9MiB allocated; 67ms collecting garbage

Counts

69 → 1

Calls

Call 1

Inputs
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) (exp.f64 (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)) (exp.f64 (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (E.f64) (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (exp.f64 (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (exp.f64 (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 2 binary64))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (exp.f64 (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 #s(approx (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (*.f64 (log.f64 im) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 #s(approx (* (log (sqrt (+ (* re re) (* im im)))) (exp (* (log (log base)) 1))) (*.f64 (log.f64 re) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 #s(approx (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) (*.f64 (log.f64 im) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 #s(approx (+ (* (exp (log (log base))) (log (sqrt (+ (* im im) (* re re))))) 0) (*.f64 (log.f64 re) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -1 binary64))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))))
(/.f64 (.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) (neg.f64 re))) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (sqrt.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -2 binary64))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (/.f64 (log.f64 (hypot.f64 im re)) (sqrt.f64 (log.f64 base))) (sqrt.f64 (log.f64 base))))
(*.f64 (log.f64 (hypot.f64 re im)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64))))
(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (exp.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (sqrt.f64 (log.f64 base)) #s(literal 4 binary64)))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(/.f64 (fma.f64 (exp.f64 (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -4 binary64)))
(/.f64 (fma.f64 (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base))) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/4 binary64)) #s(literal -2 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/4 binary64)) #s(literal -2 binary64)))))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (pow.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(literal -1 binary64)))
(/.f64 (*.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (fma.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (fma.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (hypot.f64 im re)) #s(literal 0 binary64)) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (fma.f64 (neg.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (fma.f64 (neg.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (fma.f64 (neg.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64))) (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)) #s(literal 0 binary64))))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Outputs
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))

Calls

5 calls:

38.0ms	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
32.0ms	base
29.0ms	im
24.0ms	re
20.0ms	(log.f64 base)

Results

Accuracy	Segments	Branch
99.5%	1	`(log.f64 base)`
99.5%	1	`(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))`
99.5%	1	`re`
99.5%	1	`im`
99.5%	1	`base`

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes21.0ms (0.4%)

Memory

9.3MiB live, 51.1MiB allocated; 8ms collecting garbage

Accuracy

Total -63.3b remaining (-8889.3%)

Threshold costs -63.3b (-8889.3%)

Counts

8 → 1

Calls

Call 1

Inputs
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (/ 1 (pow (log base) -1)) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) (exp.f64 (log.f64 (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)) (exp.f64 (log.f64 (log.f64 base)))))

Outputs
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Calls

5 calls:

10.0ms	re
3.0ms	base
3.0ms	(log.f64 base)
3.0ms	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
3.0ms	im

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

derivations53.0ms (0.9%)

Memory

-7.7MiB live, 37.5MiB allocated; 6ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 70 to 26 computations (62.9% saved)

preprocess38.0ms (0.6%)

Memory: -11.4MiB live, 40.6MiB allocated; 17ms collecting garbage
Compiler: Compiled 616 to 358 computations (41.9% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze176.0ms (3%)

sample1.5s (26.4%)

explain245.0ms (4.2%)

preprocess57.0ms (1%)

series151.0ms (2.6%)

rewrite250.0ms (4.3%)

eval46.0ms (0.8%)

prune12.0ms (0.2%)

series299.0ms (5.1%)

rewrite214.0ms (3.7%)

eval1.1s (19.1%)

prune50.0ms (0.9%)

series214.0ms (3.7%)

rewrite277.0ms (4.8%)

eval72.0ms (1.2%)

prune35.0ms (0.6%)

series383.0ms (6.6%)

rewrite262.0ms (4.5%)

eval118.0ms (2%)

prune43.0ms (0.7%)

regimes147.0ms (2.5%)

regimes21.0ms (0.4%)

derivations53.0ms (0.9%)

preprocess38.0ms (0.6%)

end0.0ms (0%)

Profiling