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

start0.0ms (0%)

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

analyze270.0ms (5.5%)

Memory

-47.1MiB live, 243.1MiB allocated; 118ms 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.4s (28.8%)

Memory

62.0MiB live, 2 056.5MiB allocated; 267ms collecting garbage

Samples

1.1s

8 256×

valid

Precisions

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

ival-hypot: 260.0ms (37.7% of total)

ival-log: 181.0ms (26.2% of total)

ival-mult!: 108.0ms (15.6% of total)

ival-atan2: 63.0ms (9.1% of total)

ival-add!: 38.0ms (5.5% of total)

ival-div!: 38.0ms (5.5% of total)

adjust: 2.0ms (0.3% of total)

Bogosity

explain272.0ms (5.6%)

Memory

2.4MiB live, 531.6MiB allocated; 89ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
130	-	2	(-7.92908970931845e-162 -1.3271948362148343e-244 5.709791257394219e-292)	`(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	114	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	114
↳	`(*.f64 re re)`	overflow	58
↳	`(*.f64 im im)`	overflow	74
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	14	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	14
↳	`(*.f64 re re)`	underflow	60
↳	`(*.f64 im im)`	underflow	67

Confusion

	Predicted +	Predicted -
+	128	2
-	0	126

Precision

1.0

Recall

0.9846153846153847

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	128	0	2
-	0	0	126

Precision?

1.0

Recall?

0.9846153846153847

Freqs

test

number	freq
0	128
1	128

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

72.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

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

ival-mult!: 11.0ms (23.2% of total)

ival-hypot: 10.0ms (21.1% of total)

ival-add!: 6.0ms (12.7% of total)

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

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

adjust: 0.0ms (0% of total)

preprocess33.0ms (0.7%)

Memory

-28.5MiB live, 17.9MiB allocated; 3ms 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.8%	(/.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.8%

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

series162.0ms (3.3%)

Memory

4.6MiB live, 189.1MiB allocated; 16ms 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
55.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))
51.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))
20.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))
3.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))

rewrite327.0ms (6.7%)

Memory

11.0MiB live, 301.6MiB allocated; 217ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	541	5513
0	565	4927
1	2886	4895
0	8235	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 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)))) (neg.f64 (neg.f64 (.f64 (log.f64 base) (log.f64 base)))))
(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (neg.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64))) (neg.f64 (.f64 (log.f64 base) (log.f64 base))))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
(+.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (.f64 (log.f64 base) (log.f64 base))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64))) (neg.f64 (-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64)))))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(+.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))))
(log.f64 (.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (log.f64 base))))
(.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))))
(.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im)))) (sqrt.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (sqrt.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (hypot.f64 (.f64 (.f64 re re) re) (.f64 (.f64 im im) im)) (sqrt.f64 (fma.f64 (.f64 re re) (.f64 re re) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 im im))))))
(/.f64 (hypot.f64 (.f64 (.f64 im im) im) (.f64 (.f64 re re) re)) (sqrt.f64 (fma.f64 (.f64 im im) (.f64 im im) (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 re re))))))
(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 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 (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 (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 (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 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 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im)))) (neg.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (neg.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (neg.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)))) (neg.f64 (fma.f64 (.f64 re re) (.f64 re re) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)))) (neg.f64 (fma.f64 (.f64 im im) (.f64 im im) (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (*.f64 re re))))))
(/.f64 (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) (-.f64 (.f64 re re) (.f64 im im)))
(/.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) (-.f64 (.f64 im im) (.f64 re re)))
(/.f64 (fma.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) (fma.f64 (.f64 re re) (.f64 re re) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (*.f64 im im)))))
(/.f64 (fma.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (fma.f64 (.f64 im im) (.f64 im im) (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im 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 (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 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(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 (*.f64 (log.f64 base) (log.f64 base)) #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 (*.f64 (log.f64 base) (log.f64 base)) #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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #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 (.f64 (log.f64 base) (log.f64 base)) #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 (*.f64 (log.f64 base) (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 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) base) (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 (*.f64 (log.f64 base) (log.f64 base)) #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 (*.f64 (log.f64 base) (log.f64 base)) #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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #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 (.f64 (log.f64 base) (log.f64 base)) #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 (*.f64 (log.f64 base) (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 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) base) (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 (.f64 re re) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 base))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (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 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 re re)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 base))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 base)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (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)) (*.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)) (.f64 (.f64 im im) (.f64 im im))) #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)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (log.f64 base)) (.f64 (.f64 im im) (.f64 im im)))) (.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)) (.f64 (.f64 im im) (.f64 im im))) #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)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (log.f64 base)) (.f64 (.f64 im im) (.f64 im im)))) (.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 (/.f64 (.f64 re re) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 im im) (.f64 im im)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.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) (.f64 (.f64 im im) im)) #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 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 re re)) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 im im) im))) (.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 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (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 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 base))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (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 (.f64 im im) (.f64 im im)) (/.f64 (log.f64 base) (.f64 (.f64 re re) (.f64 re re)))) #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 (.f64 im im) (.f64 im im)) (/.f64 (log.f64 base) (.f64 (.f64 re re) (.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #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 (.f64 im im) (.f64 im im)) (/.f64 (log.f64 base) (.f64 (.f64 re re) (.f64 re re)))) #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 (.f64 im im) (.f64 im im)) (/.f64 (log.f64 base) (.f64 (.f64 re re) (.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #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 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #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 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #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 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #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 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 3 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 (neg.f64 (log.f64 (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))) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 base))) #s(literal 1/2 binary64) (neg.f64 (/.f64 (neg.f64 (log.f64 (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 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (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))) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 base))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (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)) (neg.f64 (log.f64 (neg.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 (neg.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 (neg.f64 re))) (fma.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (/.f64 (log.f64 base) (.f64 (.f64 re re) (.f64 re re)))) #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 (neg.f64 re))) (fma.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (/.f64 (log.f64 base) (.f64 (.f64 re re) (.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #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 (neg.f64 re)))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.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 (neg.f64 re))) (fma.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (/.f64 (log.f64 base) (.f64 (.f64 re re) (.f64 re re)))) #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 (neg.f64 re))) (fma.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (/.f64 (log.f64 base) (.f64 (.f64 re re) (.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #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 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #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 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #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 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #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 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 3 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 (.f64 im im) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 base))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (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 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im im)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 base))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 base)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (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)) (*.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)) (.f64 (.f64 re re) (.f64 re re))) #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)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (log.f64 base)) (.f64 (.f64 re re) (.f64 re re)))) (.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)) (.f64 (.f64 re re) (.f64 re re))) #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)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (log.f64 base)) (.f64 (.f64 re re) (.f64 re re)))) (.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 (/.f64 (.f64 im im) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 re re) (.f64 re re)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.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) (.f64 (.f64 re re) re)) #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 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 im im)) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 re re) re))) (.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 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (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 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 base))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (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 (.f64 (.f64 re re) (.f64 re re)) (/.f64 (log.f64 base) (.f64 (.f64 im im) (.f64 im im)))) #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 (.f64 (.f64 re re) (.f64 re re)) (/.f64 (log.f64 base) (.f64 (.f64 im im) (.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #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 (.f64 (.f64 re re) (.f64 re re)) (/.f64 (log.f64 base) (.f64 (.f64 im im) (.f64 im im)))) #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 (.f64 (.f64 re re) (.f64 re re)) (/.f64 (log.f64 base) (.f64 (.f64 im im) (.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #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 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #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 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #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 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #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 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 3 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 (neg.f64 (log.f64 (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))) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 base))) #s(literal 1/2 binary64) (neg.f64 (/.f64 (neg.f64 (log.f64 (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 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (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))) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 base))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (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)) (neg.f64 (log.f64 (neg.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 (neg.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 (neg.f64 im))) (fma.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 (log.f64 base) (.f64 (.f64 im im) (.f64 im im)))) #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 (neg.f64 im))) (fma.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 (log.f64 base) (.f64 (.f64 im im) (.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #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 (neg.f64 im)))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.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 (neg.f64 im))) (fma.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 (log.f64 base) (.f64 (.f64 im im) (.f64 im im)))) #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 (neg.f64 im))) (fma.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 (log.f64 base) (.f64 (.f64 im im) (.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (log.f64 base)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #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 (neg.f64 (log.f64 (neg.f64 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 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #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)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #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 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #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 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 3 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 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))))
#s(approx (log base) (log.f64 base))
#s(approx base base)
#s(approx (+ (* (log base) (log base)) (* 0 0)) (*.f64 (log.f64 base) (log.f64 base)))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (*.f64 (log.f64 base) (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 (sqrt.f64 (fma.f64 im im (*.f64 re 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 (sqrt.f64 (fma.f64 im im (.f64 re re)))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (neg.f64 (.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))))))
#s(approx (log base) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (*.f64 (log.f64 base) (log.f64 base)))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (*.f64 (log.f64 base) (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 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64)))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64)))))
#s(approx (log base) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (pow.f64 (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (pow.f64 (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64))) #s(literal 2 binary64)))

eval47.0ms (1%)

Memory: 1.9MiB live, 95.4MiB allocated; 9ms collecting garbage
Compiler: Compiled 13 390 to 1 726 computations (87.1% saved)

prune18.0ms (0.4%)

Memory

-7.0MiB live, 39.9MiB allocated; 2ms collecting garbage

Pruning

21 alts after pruning (21 fresh and 0 done)

	Pruned	Kept	Total
New	318	21	339
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	319	21	340

Accuracy

99.8%

Counts

340 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
	50.6%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	50.8%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
	49.2%	(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	49.2%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	99.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re 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))))
▶	50.8%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.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))))
	26.5%	(/.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))) (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64)))
	50.7%	(/.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 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	50.7%	(/.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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	23.4%	(/.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))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	26.7%	(/.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))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	87.0%	#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))))
	50.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
	10.9%	#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.8%	#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)))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (neg.f64 (log.f64 (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))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))))

Compiler

Compiled 1 444 to 918 computations (36.4% saved)

series233.0ms (4.8%)

Memory

35.2MiB live, 456.1MiB allocated; 85ms collecting garbage

Counts

40 → 365

Calls

Call 1

Inputs
(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base))
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
re
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))) (/.f64 (log.f64 im) (log.f64 base)))
(/.f64 (log.f64 im) (log.f64 base))
(log.f64 im)
#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))))
(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)))
(/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 base)))
(*.f64 re re)
(.f64 (.f64 im im) (log.f64 base))
(*.f64 im im)
#s(literal 1/2 binary64)
(/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.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)))) (/.f64 #s(literal 1 binary64) (pow.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)))) (/.f64 #s(literal 1 binary64) (pow.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 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))
#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 (+ (* 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 #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 (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (/ (log im) (log base))))
#s(approx (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))))
#s(approx (/ (* re re) (* (* im im) (log base))) #s(hole binary64 (/ (pow re 2) (* (pow im 2) (log base)))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #s(hole binary64 (/ (log im) (log base))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #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) (* (log base) (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 base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (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 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)))) #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 (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log im))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) #s(hole binary64 (* (log base) (log im))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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 (+ (* 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 (/ (+ (* (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) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))
#s(approx (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log base)))) (/ (log im) (* (pow re 2) (log base)))))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log base)))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #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) (* (log base) (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 base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (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 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)))) #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 (+ (* im im) (* re re)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 re))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) #s(hole binary64 (* -1 (* (log base) (log (/ 1 re))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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 (+ (* 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 base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log base)))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #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) (* (log base) (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 base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (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 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)))) #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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ -1 re))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) #s(hole binary64 (* -1 (* (log base) (log (/ -1 re))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (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 #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 (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log base))) (/ (* (pow im 2) (log im)) (log base))) (pow im 2))))
#s(approx (* (* im im) (log base)) #s(hole binary64 (* (pow im 2) (log base))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #s(hole binary64 (/ (log re) (log base))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #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) (* (log base) (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 base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (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 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)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log re))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) #s(hole binary64 (* (log base) (log re))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (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 (/ (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 (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log base)))))
#s(approx (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #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) (* (log base) (log base))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log base)))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #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) (* (log base) (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 base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (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 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)))) #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 (+ (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) #s(hole binary64 (* -1 (* (log base) (log (/ 1 im))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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 (+ (* 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 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 (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (/ (log -1) (log base)))))
#s(approx (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log -1) (log base))))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log base)))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #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) (* (log base) (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 base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (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 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)))) #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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ -1 im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) #s(hole binary64 (* -1 (* (log base) (log (/ -1 im))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (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 base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #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 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) #s(hole binary64 (* (log base) (log (sqrt (+ (pow im 2) (pow re 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 (+ (* 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 im) (log base)) #s(hole binary64 (* -1 (/ (log im) (log (/ 1 base))))))
#s(approx (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (+ (* -1 (/ (log im) (log (/ 1 base)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 base))))))))
#s(approx (/ (* re re) (* (* im im) (log base))) #s(hole binary64 (* -1 (/ (pow re 2) (* (pow im 2) (log (/ 1 base)))))))
#s(approx (* (* im im) (log base)) #s(hole binary64 (* -1 (* (pow im 2) (log (/ 1 base))))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #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 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) #s(hole binary64 (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))))
#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 (+ (* 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)))
#s(approx (/ (log im) (log base)) #s(hole binary64 (/ (log im) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))) (/ (log im) (+ (log -1) (* -1 (log (/ -1 base))))))))
#s(approx (/ (* re re) (* (* im im) (log base))) #s(hole binary64 (/ (pow re 2) (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base))))))))
#s(approx (* (* im im) (log base)) #s(hole binary64 (* (pow im 2) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) #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 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (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)))) (/ 1 (pow (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)))) (/ 1 (pow (log base) -1))) #s(hole binary64 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))))
#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
63.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 im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) (/ (* re re) (* (* im im) (log base))) (* re re) (* (* im im) (log base)) (* im im) 1/2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1)
34.0ms	re	@	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 im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) (/ (* re re) (* (* im im) (log base))) (* re re) (* (* im im) (log base)) (* im im) 1/2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1)
28.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 im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) (/ (* re re) (* (* im im) (log base))) (* re re) (* (* im im) (log base)) (* im im) 1/2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1)
27.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 im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) (/ (* re re) (* (* im im) (log base))) (* re re) (* (* im im) (log base)) (* im im) 1/2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1)
18.0ms	im	@	-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 im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (/ (* re re) (* (* im im) (log base))) 1/2) (/ (log im) (log base))) (/ (* re re) (* (* im im) (log base))) (* re re) (* (* im im) (log base)) (* im im) 1/2 (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1)

rewrite222.0ms (4.6%)

Memory

-20.9MiB live, 364.6MiB allocated; 61ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	824	13252
0	890	10722
1	3502	10640
0	8569	10265

Stop Event

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

Counts

405 → 934

Calls

Call 1

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

eval85.0ms (1.7%)

Memory: 20.3MiB live, 207.6MiB allocated; 16ms collecting garbage
Compiler: Compiled 23 965 to 2 559 computations (89.3% saved)

prune36.0ms (0.7%)

Memory

16.4MiB live, 111.1MiB allocated; 3ms collecting garbage

Pruning

33 alts after pruning (31 fresh and 2 done)

	Pruned	Kept	Total
New	632	20	652
Fresh	5	11	16
Picked	3	2	5
Done	0	0	0
Total	640	33	673

Accuracy

99.9%

Counts

673 → 33

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	50.8%	(/.f64 (fma.f64 (/.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) (log.f64 base)) (.f64 (log.f64 base) (log.f64 base)) (.f64 (log.f64 base) #s(literal 0 binary64))) (.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 base))))
	50.8%	(/.f64 (fma.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
	50.6%	(/.f64 (fma.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	50.7%	(/.f64 (fma.f64 (neg.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (neg.f64 (.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64))) (.f64 (neg.f64 (.f64 (log.f64 base) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base))))
	26.9%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (.f64 (*.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))) (log.f64 base)))
	6.4%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 #s(approx (+ (* im im) (* re re)) (.f64 re re)))) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
▶	50.2%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 #s(approx (+ (* im im) (* re re)) (.f64 im im)))) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
	50.7%	(/.f64 (/.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (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%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal -2 binary64)))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re 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 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re 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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	98.8%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
▶	99.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	26.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (.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(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))))
	50.7%	(/.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 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	50.7%	(/.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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	23.4%	(/.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))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	50.8%	(/.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
✓	87.0%	#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))))
▶	47.7%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (fma.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 base) (.f64 (.f64 (.f64 im im) (log.f64 base)) (log.f64 im))) (.f64 (.f64 (.f64 im im) (log.f64 base)) (log.f64 base))))
	87.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (-.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 base)) #s(literal 2 binary64)) (pow.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 (.f64 im im) (log.f64 base))) #s(literal 2 binary64))) (-.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 (.f64 im im) (log.f64 base))))))
	50.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
▶	10.9%	#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)))
	51.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (*.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)))))
✓	98.8%	#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)))
	50.7%	#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 (*.f64 (log.f64 (log.f64 base)) #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))) (neg.f64 (/.f64 (neg.f64 (log.f64 (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))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))))

Compiler

Compiled 2 162 to 1 350 computations (37.6% saved)

series248.0ms (5.1%)

Memory

-33.0MiB live, 639.3MiB allocated; 52ms collecting garbage

Counts

42 → 402

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
42.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 im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* im im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* (* im im) (log base)) (log base))) (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* re re) 1/2) (* re re) 1/2 (* (* (* im im) (log base)) (log im)) (* (* im im) (log base)) (log im) (* (* (* im im) (log base)) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* (log base) 0) (* (log base) (* (log base) (log base))))
33.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 im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* im im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* (* im im) (log base)) (log base))) (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* re re) 1/2) (* re re) 1/2 (* (* (* im im) (log base)) (log im)) (* (* im im) (log base)) (log im) (* (* (* im im) (log base)) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* (log base) 0) (* (log base) (* (log base) (log base))))
31.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 im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* im im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* (* im im) (log base)) (log base))) (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* re re) 1/2) (* re re) 1/2 (* (* (* im im) (log base)) (log im)) (* (* im im) (log base)) (log im) (* (* (* im im) (log base)) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* (log base) 0) (* (log base) (* (log base) (log base))))
28.0ms	im	@	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 im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* im im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* (* im im) (log base)) (log base))) (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* re re) 1/2) (* re re) 1/2 (* (* (* im im) (log base)) (log im)) (* (* im im) (log base)) (log im) (* (* (* im im) (log base)) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* (log base) 0) (* (log base) (* (log base) (log base))))
23.0ms	re	@	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 im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* im im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* (* im im) (log base)) (log base))) (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (* (* re re) 1/2) (* re re) 1/2 (* (* (* im im) (log base)) (log im)) (* (* im im) (log base)) (log im) (* (* (* im im) (log base)) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* (log base) 0) (* (log base) (* (log base) (log base))))

rewrite242.0ms (5%)

Memory

38.9MiB live, 313.6MiB allocated; 41ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	978	15451
0	1057	12670
1	4474	12507
0	8138	12097

Stop Event

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

Counts

444 → 770

Calls

Call 1

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

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

eval88.0ms (1.8%)

Memory: -15.0MiB live, 172.0MiB allocated; 33ms collecting garbage
Compiler: Compiled 30 122 to 2 660 computations (91.2% saved)

prune30.0ms (0.6%)

Memory

23.8MiB live, 71.3MiB allocated; 1ms collecting garbage

Pruning

31 alts after pruning (28 fresh and 3 done)

	Pruned	Kept	Total
New	632	13	645
Fresh	11	15	26
Picked	4	1	5
Done	0	2	2
Total	647	31	678

Accuracy

99.9%

Counts

678 → 31

Alt Table

Click to see full alt table

Status	Accuracy	Program
	50.8%	(/.f64 (fma.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
	50.6%	(/.f64 (fma.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	50.7%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
	50.7%	(/.f64 (fma.f64 (neg.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (neg.f64 (.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64))) (.f64 (neg.f64 (.f64 (log.f64 base) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base))))
	6.4%	(/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 #s(approx (+ (* im im) (* re re)) (.f64 re re)))) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
	50.7%	(/.f64 (/.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.9%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal -2 binary64)))
▶	98.8%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
▶	99.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
	26.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (.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(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))))
	50.8%	(/.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)))
	50.2%	(/.f64 (.f64 (log.f64 (sqrt.f64 #s(approx (+ ( im im) (* re re)) (.f64 im im)))) (log.f64 base)) (.f64 (log.f64 base) (log.f64 base)))
▶	98.6%	(/.f64 #s(approx (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (.f64 (.f64 (log.f64 base) (log.f64 base)) (log.f64 im))) (.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 base))))
	0.0%	(/.f64 #s(approx (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (neg.f64 (.f64 (neg.f64 (log.f64 (neg.f64 re))) (.f64 (log.f64 base) (log.f64 base))))) (.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 base))))
	0.0%	(/.f64 #s(approx (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (neg.f64 (.f64 (neg.f64 (log.f64 (neg.f64 im))) (.f64 (log.f64 base) (log.f64 base))))) (.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 base))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	50.9%	#s(approx (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))))
▶	0.0%	#s(approx (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))))
✓	87.0%	#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))))
	87.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (-.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 base)) #s(literal 2 binary64)) (pow.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 (.f64 im im) (log.f64 base))) #s(literal 2 binary64))) (-.f64 (/.f64 (log.f64 im) (log.f64 base)) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 (.f64 im im) (log.f64 base))))))
✓	10.9%	#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.8%	#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)))
	50.7%	#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 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
	47.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (.f64 (.f64 (log.f64 im) (log.f64 base)) (.f64 im im))) (.f64 (.f64 (.f64 im im) (log.f64 base)) (log.f64 base))))

Compiler

Compiled 2 110 to 1 276 computations (39.5% saved)

series372.0ms (7.6%)

Memory

-15.9MiB live, 574.1MiB allocated; 139ms collecting garbage

Counts

37 → 296

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
107.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (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 im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (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 re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (* (log base) (log base)) (log im)) (log im) (* (log base) (* (log base) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)))
91.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (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 im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (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 re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (* (log base) (log base)) (log im)) (log im) (* (log base) (* (log base) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)))
43.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (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 im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (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 re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (* (log base) (log base)) (log im)) (log im) (* (log base) (* (log base) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)))
26.0ms	im	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (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 im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (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 re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (* (log base) (log base)) (log im)) (log im) (* (log base) (* (log base) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)))
25.0ms	im	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (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 im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (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 re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (* (log base) (log base)) (log im)) (log im) (* (log base) (* (log base) (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)))

rewrite271.0ms (5.6%)

Memory

17.4MiB live, 390.2MiB allocated; 37ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	839	11790
0	898	9524
1	4036	9442
0	8787	9003

Stop Event

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

Counts

333 → 688

Calls

Call 1

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

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

eval145.0ms (3%)

Memory: -26.4MiB live, 165.9MiB allocated; 19ms collecting garbage
Compiler: Compiled 36 936 to 2 958 computations (92% saved)

prune57.0ms (1.2%)

Memory

15.7MiB live, 121.6MiB allocated; 22ms collecting garbage

Pruning

38 alts after pruning (33 fresh and 5 done)

	Pruned	Kept	Total
New	855	22	877
Fresh	12	11	23
Picked	3	2	5
Done	0	3	3
Total	870	38	908

Accuracy

99.9%

Counts

908 → 38

Alt Table

Click to see full alt table

Status	Accuracy	Program
	50.8%	(/.f64 (fma.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
	50.7%	(/.f64 (fma.f64 (neg.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (neg.f64 (.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64))) (.f64 (neg.f64 (.f64 (log.f64 base) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base))))
	50.5%	(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	49.0%	(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)) (-.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	50.7%	(/.f64 (/.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
	46.9%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal -2 binary64)))))
	98.9%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal -2 binary64)))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 base))))
✓	99.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
	26.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (.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(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))))
	50.8%	(/.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)))
	98.4%	(/.f64 #s(approx (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (.f64 (/.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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))) (log.f64 im))) (.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 base))))
	98.5%	(/.f64 #s(approx (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (.f64 (.f64 (log.f64 base) (log.f64 base)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
✓	98.6%	(/.f64 #s(approx (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (.f64 (.f64 (log.f64 base) (log.f64 base)) (log.f64 im))) (.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 base))))
	0.0%	(/.f64 #s(approx (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (neg.f64 (.f64 (neg.f64 (log.f64 (neg.f64 im))) (.f64 (log.f64 base) (log.f64 base))))) (.f64 (log.f64 base) (.f64 (log.f64 base) (log.f64 base))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (.f64 (log.f64 base) (log.f64 base)))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (/.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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (/.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 base))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (log.f64 base)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)))
	98.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)))
	50.8%	(.f64 (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base) #s(literal 0 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
	50.9%	#s(approx (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))))
	0.0%	#s(approx (/ (+ (* (/ (* (log (sqrt (+ (* im im) (* re re)))) (log base)) (log base)) (* (log base) (log base))) (* (log base) 0)) (* (log base) (* (log base) (log base)))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))))))
✓	87.0%	#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))))
✓	10.9%	#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.8%	#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)))
	50.7%	#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 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
	47.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (+ (* (* (* re re) 1/2) (log base)) (* (* (* im im) (log base)) (log im))) (.f64 (.f64 (log.f64 im) (log.f64 base)) (.f64 im im))) (.f64 (.f64 (.f64 im im) (log.f64 base)) (log.f64 base))))

Compiler

Compiled 4 024 to 1 155 computations (71.3% saved)

regimes112.0ms (2.3%)

Memory

-3.9MiB live, 274.5MiB allocated; 26ms collecting garbage

Counts

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

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

Calls

5 calls:

26.0ms	re
22.0ms	im
21.0ms	base
21.0ms	(log.f64 base)
17.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))))

Results

Accuracy	Segments	Branch
99.3%	1	`(log.f64 base)`
99.3%	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.3%	1	`re`
99.3%	1	`im`
99.3%	1	`base`

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes50.0ms (1%)

Memory

-9.7MiB live, 90.4MiB allocated; 5ms collecting garbage

Accuracy

Total -63.2b remaining (-8280.8%)

Threshold costs -63.2b (-8280.8%)

Counts

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

Calls

5 calls:

17.0ms	(log.f64 base)
9.0ms	im
7.0ms	base
7.0ms	re
7.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))))

Results

Accuracy	Segments	Branch
98.8%	1	`(log.f64 base)`
98.8%	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.8%	1	`re`
98.8%	1	`im`
98.8%	1	`base`

Compiler

Compiled 33 to 31 computations (6.1% saved)

derivations107.0ms (2.2%)

Memory

22.8MiB live, 115.2MiB allocated; 4ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 55 to 30 computations (45.5% saved)

preprocess40.0ms (0.8%)

Memory: -21.2MiB live, 72.4MiB allocated; 9ms collecting garbage
Compiler: Compiled 496 to 318 computations (35.9% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze270.0ms (5.5%)

sample1.4s (28.8%)

explain272.0ms (5.6%)

preprocess33.0ms (0.7%)

series162.0ms (3.3%)

rewrite327.0ms (6.7%)

eval47.0ms (1%)

prune18.0ms (0.4%)

series233.0ms (4.8%)

rewrite222.0ms (4.6%)

eval85.0ms (1.7%)

prune36.0ms (0.7%)

series248.0ms (5.1%)

rewrite242.0ms (5%)

eval88.0ms (1.8%)

prune30.0ms (0.6%)

series372.0ms (7.6%)

rewrite271.0ms (5.6%)

eval145.0ms (3%)

prune57.0ms (1.2%)

regimes112.0ms (2.3%)

regimes50.0ms (1%)

derivations107.0ms (2.2%)

preprocess40.0ms (0.8%)

end0.0ms (0%)

Profiling