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

start0.0ms (0%)

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

analyze223.0ms (3.3%)

Memory

21.1MiB live, 495.7MiB allocated; 66ms 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.9s (27.8%)

Memory

55.3MiB live, 2 507.0MiB allocated; 538ms collecting garbage

Samples

1.4s

8 256×

valid

Precisions

Click to see histograms. Total time spent on operations: 1.1s

ival-mult: 400.0ms (37% of total)

ival-hypot: 256.0ms (23.7% of total)

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

ival-add: 79.0ms (7.3% of total)

ival-atan2: 66.0ms (6.1% of total)

ival-div: 50.0ms (4.6% of total)

ival-true: 6.0ms (0.6% of total)

exact: 5.0ms (0.5% of total)

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

adjust: 2.0ms (0.2% of total)

Bogosity

explain387.0ms (5.7%)

Memory

15.1MiB live, 491.5MiB allocated; 70ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
125	-	3	(-1.374010106819415e-284 3.386706623206122e-159 2.621069270658854e-278)	`(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	109	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	109
↳	`(*.f64 re re)`	overflow	62
↳	`(*.f64 im im)`	overflow	59
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	13	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	13
↳	`(*.f64 re re)`	underflow	61
↳	`(*.f64 im im)`	underflow	61

Confusion

	Predicted +	Predicted -
+	122	3
-	0	131

Precision

1.0

Recall

0.976

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	122	0	3
-	0	0	131

Precision?

1.0

Recall?

0.976

Freqs

test

number	freq
0	134
1	122

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

138.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

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

ival-log: 33.0ms (29.2% of total)

ival-mult: 15.0ms (13.3% of total)

ival-add: 7.0ms (6.2% of total)

ival-div: 6.0ms (5.3% of total)

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

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

preprocess191.0ms (2.8%)

Memory

-38.2MiB live, 210.4MiB allocated; 44ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	76	189
1	226	171
2	1240	128
0	18	26
0	34	20
1	64	18
2	187	14
3	980	12
4	2597	12
5	5226	12
0	8120	7

Stop Event

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

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))))

Outputs

(/.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 (log.f64 (hypot.f64 im re)) (log.f64 base))

Symmetry

(abs im)

(abs re)

(sort re im)

Compiler

Compiled 28 to 18 computations (35.7% saved)

eval0.0ms (0%)

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

prune1.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

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

Status

Accuracy

Program

▶

53.2%

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

Compiler

Compiled 28 to 18 computations (35.7% saved)

series192.0ms (2.8%)

Memory

20.6MiB live, 201.8MiB allocated; 59ms 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
97.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))
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 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))
24.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 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))
19.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
4.0ms	re	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))

simplify240.0ms (3.6%)

Memory

6.0MiB live, 329.2MiB allocated; 40ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	527	4879
1	1344	4635
2	5743	4563
0	8508	3715

Stop Event

1×	iter limit
1×	node limit

Counts

148 → 148

Calls

Call 1

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

rewrite72.0ms (1.1%)

Memory

19.7MiB live, 71.3MiB allocated; 14ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	18	113
0	34	92
1	121	90
0	978	64

Stop Event

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

Counts

18 → 357

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

eval91.0ms (1.3%)

Memory: 11.1MiB live, 140.6MiB allocated; 25ms collecting garbage
Compiler: Compiled 12 941 to 1 883 computations (85.4% saved)

prune72.0ms (1.1%)

Memory

-90.9MiB live, 58.1MiB allocated; 69ms collecting garbage

Pruning

13 alts after pruning (13 fresh and 0 done)

	Pruned	Kept	Total
New	392	13	405
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	393	13	406

Accuracy

99.9%

Counts

406 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.1%	(/.f64 (fma.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.1%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.2%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.3%	(/.f64 (-.f64 (.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 0 binary64)) (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.2%	(/.f64 (+.f64 (pow.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))) #s(literal 0 binary64)))))
	98.7%	(/.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))))
▶	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.4%	(*.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	99.3%	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	93.2%	#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 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im)) (log.f64 base)))
▶	99.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
▶	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 734 to 426 computations (42% saved)

series287.0ms (4.2%)

Memory

26.7MiB live, 597.2MiB allocated; 66ms collecting garbage

Counts

27 → 366

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
70.0ms	im	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (pow (log base) 2) 2 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (pow (log base) 4) 4 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))
66.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (pow (log base) 2) 2 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (pow (log base) 4) 4 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))
40.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (pow (log base) 2) 2 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (pow (log base) 4) 4 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))
32.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (pow (log base) 2) 2 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (pow (log base) 4) 4 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))
27.0ms	im	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log base) base (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (* (log base) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2))) (/ (log (sqrt (+ (* im im) (* re re)))) (pow (log base) 2)) (pow (log base) 2) 2 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (pow (log base) 4) 4 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2))

simplify490.0ms (7.3%)

Memory

1.9MiB live, 579.8MiB allocated; 59ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1405	16603
1	3871	16479
0	8934	13989

Stop Event

1×	iter limit
1×	node limit

Counts

366 → 366

Calls

Call 1

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

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

rewrite73.0ms (1.1%)

Memory

-2.9MiB live, 140.4MiB allocated; 11ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	42	221
0	62	193
0	226	191

Stop Event

1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit

Counts

27 → 89

Calls

Call 1

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

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

eval119.0ms (1.8%)

Memory: -13.3MiB live, 319.2MiB allocated; 32ms collecting garbage
Compiler: Compiled 37 322 to 2 754 computations (92.6% saved)

prune68.0ms (1%)

Memory

22.7MiB live, 154.5MiB allocated; 33ms collecting garbage

Pruning

19 alts after pruning (17 fresh and 2 done)

	Pruned	Kept	Total
New	854	12	866
Fresh	3	5	8
Picked	3	2	5
Done	0	0	0
Total	860	19	879

Accuracy

100.0%

Counts

879 → 19

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.1%	(/.f64 (fma.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 (.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (log.f64 base)) #s(literal 2 binary64)))
	98.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 #s(approx (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (*.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.2%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.8%	(/.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal 3 binary64))) (.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	99.1%	(/.f64 (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
	98.7%	(/.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))))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	98.5%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(.f64 (.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 6 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.4%	(*.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.1%	(*.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))
	98.8%	(.f64 (log.f64 base) (/.f64 (log.f64 (hypot.f64 im re)) (/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))))
	98.6%	(.f64 (log.f64 base) (/.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
▶	98.6%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.3%	#s(approx (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (pow (log base) 2))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 base))))
✓	99.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
▶	53.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
✓	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 950 to 631 computations (33.6% saved)

series856.0ms (12.7%)

Memory

-36.8MiB live, 647.9MiB allocated; 999ms collecting garbage

Counts

34 → 405

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
589.0ms	base	@	-inf	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (log im) (pow (log base) 5) 5 (pow (log base) 4) 4 (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)))
73.0ms	base	@	inf	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (log im) (pow (log base) 5) 5 (pow (log base) 4) 4 (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)))
50.0ms	im	@	-inf	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (log im) (pow (log base) 5) 5 (pow (log base) 4) 4 (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)))
41.0ms	im	@	0	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (log im) (pow (log base) 5) 5 (pow (log base) 4) 4 (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)))
34.0ms	base	@	0	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (log base) base (pow (log base) 2) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (pow (log base) 4)) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (log im) (pow (log base) 5) 5 (pow (log base) 4) 4 (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6) 6 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)))

simplify275.0ms (4.1%)

Memory

-14.0MiB live, 413.1MiB allocated; 57ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1435	17823
1	3948	17727
0	8688	15059

Stop Event

1×	iter limit
1×	node limit

Counts

405 → 405

Calls

Call 1

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

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

rewrite42.0ms (0.6%)

Memory

30.3MiB live, 76.1MiB allocated; 7ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	55	252
0	82	240
0	260	239

Stop Event

1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit

Counts

34 → 133

Calls

Call 1

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

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

eval162.0ms (2.4%)

Memory: -36.0MiB live, 196.7MiB allocated; 122ms collecting garbage
Compiler: Compiled 34 681 to 2 740 computations (92.1% saved)

prune30.0ms (0.4%)

Memory

30.5MiB live, 76.4MiB allocated; 6ms collecting garbage

Pruning

21 alts after pruning (17 fresh and 4 done)

	Pruned	Kept	Total
New	824	12	836
Fresh	7	5	12
Picked	3	2	5
Done	0	2	2
Total	834	21	855

Accuracy

100.0%

Counts

855 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	97.9%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 #s(approx ( (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 2 binary64)))
	98.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 #s(approx (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (*.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.9%	(/.f64 (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
	98.4%	(/.f64 (.f64 (.f64 (log.f64 base) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
	99.1%	(/.f64 (.f64 (log.f64 base) (.f64 (log.f64 (hypot.f64 re im)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
	98.7%	(/.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))))
▶	98.6%	(/.f64 #s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (*.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
	99.1%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	98.5%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.2%	(.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 re im))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))))
	98.8%	(.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))))
▶	99.4%	(*.f64 (log.f64 (hypot.f64 im re)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
	98.7%	(.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.6%	(.f64 (log.f64 base) (/.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
✓	98.6%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	98.3%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	49.2%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (*.f64 (pow.f64 (log.f64 base) #s(literal 5/2 binary64)) (pow.f64 (log.f64 base) #s(literal 5/2 binary64))))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.3%	#s(approx (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 base))))
✓	99.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
✓	53.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
✓	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 1 068 to 722 computations (32.4% saved)

series189.0ms (2.8%)

Memory

-3.2MiB live, 325.5MiB allocated; 64ms collecting garbage

Counts

38 → 379

Calls

Call 1

Inputs
(*.f64 (log.f64 (hypot.f64 im re)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
#s(literal 1 binary64)
(log.f64 base)
base
#s(approx (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 base))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 base)))
(/.f64 #s(literal 1/2 binary64) (log.f64 base))
#s(literal 1/2 binary64)
(*.f64 (/.f64 re im) (/.f64 re im))
(/.f64 re im)
(/.f64 (log.f64 im) (log.f64 base))
(log.f64 im)
(/.f64 #s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (*.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (*.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (log.f64 im)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (log.f64 im))
(pow.f64 (log.f64 base) #s(literal 5 binary64))
#s(literal 5 binary64)
(pow.f64 (log.f64 base) #s(literal 6 binary64))
#s(literal 6 binary64)
(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64))))
(/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 #s(approx ( (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 2 binary64)))
(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64))
(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
#s(literal 3 binary64)
(pow.f64 #s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 2 binary64))
#s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64)))

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

Calls

9 calls:

Time	Variable		Point	Expression
39.0ms	base	@	inf	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (/ 1 (log base)) 1 (log base) base (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (+ (* (/ 1/2 (log base)) (* (/ re im) (/ re im))) (/ (log im) (log base))) (/ 1/2 (log base)) 1/2 (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log base)) (log im) (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (pow (log base) 5) (log im)) (pow (log base) 5) 5 (pow (log base) 6) 6 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (pow (log base) 2) (pow (log base) 2))) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (pow (log base) 2) (pow (log base) 2)) (pow (log base) 2) 2 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (* (log im) (pow (log base) 2)))
30.0ms	base	@	-inf	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (/ 1 (log base)) 1 (log base) base (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (+ (* (/ 1/2 (log base)) (* (/ re im) (/ re im))) (/ (log im) (log base))) (/ 1/2 (log base)) 1/2 (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log base)) (log im) (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (pow (log base) 5) (log im)) (pow (log base) 5) 5 (pow (log base) 6) 6 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (pow (log base) 2) (pow (log base) 2))) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (pow (log base) 2) (pow (log base) 2)) (pow (log base) 2) 2 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (* (log im) (pow (log base) 2)))
28.0ms	base	@	0	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (/ 1 (log base)) 1 (log base) base (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (+ (* (/ 1/2 (log base)) (* (/ re im) (/ re im))) (/ (log im) (log base))) (/ 1/2 (log base)) 1/2 (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log base)) (log im) (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (pow (log base) 5) (log im)) (pow (log base) 5) 5 (pow (log base) 6) 6 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (pow (log base) 2) (pow (log base) 2))) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (pow (log base) 2) (pow (log base) 2)) (pow (log base) 2) 2 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (* (log im) (pow (log base) 2)))
21.0ms	im	@	-inf	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (/ 1 (log base)) 1 (log base) base (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (+ (* (/ 1/2 (log base)) (* (/ re im) (/ re im))) (/ (log im) (log base))) (/ 1/2 (log base)) 1/2 (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log base)) (log im) (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (pow (log base) 5) (log im)) (pow (log base) 5) 5 (pow (log base) 6) 6 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (pow (log base) 2) (pow (log base) 2))) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (pow (log base) 2) (pow (log base) 2)) (pow (log base) 2) 2 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (* (log im) (pow (log base) 2)))
20.0ms	im	@	0	((* (log (sqrt (+ (* im im) (* re re)))) (/ (log base) (pow (log base) 2))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (/ (log base) (pow (log base) 2)) (/ 1 (log base)) 1 (log base) base (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (+ (* (/ 1/2 (log base)) (* (/ re im) (/ re im))) (/ (log im) (log base))) (/ 1/2 (log base)) 1/2 (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log base)) (log im) (/ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (pow (log base) 6)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (* (pow (log base) 5) (log im)) (pow (log base) 5) 5 (pow (log base) 6) 6 (* (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (* (pow (log base) 2) (pow (log base) 2))) (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/ (log im) (pow (log base) 5)) (* (pow (log base) 2) (pow (log base) 2)) (pow (log base) 2) 2 (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3 (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (* (log im) (pow (log base) 2)))

simplify234.0ms (3.5%)

Memory

17.6MiB live, 441.8MiB allocated; 84ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1433	16228
1	3990	16081
0	8859	13783

Stop Event

1×	iter limit
1×	node limit

Counts

379 → 379

Calls

Call 1

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

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

rewrite42.0ms (0.6%)

Memory

-6.0MiB live, 94.9MiB allocated; 7ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	56	350
0	86	334
0	244	334

Stop Event

1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit

Counts

38 → 105

Calls

Call 1

Inputs
(*.f64 (log.f64 (hypot.f64 im re)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re
#s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (log.f64 base))
#s(literal 1 binary64)
(log.f64 base)
base
#s(approx (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 base))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 base)))
(/.f64 #s(literal 1/2 binary64) (log.f64 base))
#s(literal 1/2 binary64)
(*.f64 (/.f64 re im) (/.f64 re im))
(/.f64 re im)
(/.f64 (log.f64 im) (log.f64 base))
(log.f64 im)
(/.f64 #s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (*.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
#s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (*.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (log.f64 im)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (log.f64 im))
(pow.f64 (log.f64 base) #s(literal 5 binary64))
#s(literal 5 binary64)
(pow.f64 (log.f64 base) #s(literal 6 binary64))
#s(literal 6 binary64)
(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
#s(approx (/ (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64))))
(/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (pow.f64 #s(approx ( (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 2 binary64)))
(pow.f64 (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64))
(*.f64 (log.f64 base) (log.f64 (hypot.f64 im re)))
#s(literal 3 binary64)
(pow.f64 #s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 2 binary64))
#s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
(*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64)))

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

eval79.0ms (1.2%)

Memory: -9.0MiB live, 178.5MiB allocated; 26ms collecting garbage
Compiler: Compiled 30 411 to 2 225 computations (92.7% saved)

prune32.0ms (0.5%)

Memory

-2.0MiB live, 91.7MiB allocated; 5ms collecting garbage

Pruning

22 alts after pruning (16 fresh and 6 done)

	Pruned	Kept	Total
New	615	8	623
Fresh	4	8	12
Picked	3	2	5
Done	0	4	4
Total	622	22	644

Accuracy

100.0%

Counts

644 → 22

Alt Table

Click to see full alt table

Status	Accuracy	Program
	70.9%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (exp.f64 (.f64 (log.f64 #s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) (log.f64 im)))) #s(literal 2 binary64))))
	98.0%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im))) #s(literal 3 binary64)) (pow.f64 #s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) (*.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 2 binary64)))) #s(literal 2 binary64)))
	98.4%	(/.f64 (.f64 (.f64 (log.f64 base) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
	98.7%	(/.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))))
✓	98.6%	(/.f64 #s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (*.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
	98.4%	(/.f64 #s(approx (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 4)) (.f64 (pow.f64 (log.f64 base) #s(literal 5 binary64)) (log.f64 im))) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (pow.f64 (log.f64 base) #s(literal 3 binary64))))
	98.5%	(.f64 (/.f64 (.f64 (log.f64 base) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (pow.f64 (log.f64 base) #s(literal 6 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.2%	(.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 re im))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 base) #s(literal 6 binary64))))
	98.8%	(.f64 (log.f64 (hypot.f64 im re)) (/.f64 (log.f64 base) (/.f64 (+.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64)))))))
	98.7%	(.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im)) (/.f64 (log.f64 base) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.8%	(.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im)) #s(approx (/ (log base) (pow (log base) 2)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
	98.6%	(.f64 (log.f64 base) (/.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.3%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 2 binary64)))
✓	98.6%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 5 binary64)))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	49.2%	(.f64 #s(approx (/ ( (log base) (log (sqrt (+ (* im im) (* re re))))) (pow (log base) 6)) (/.f64 (log.f64 im) (*.f64 (pow.f64 (log.f64 base) #s(literal 5/2 binary64)) (pow.f64 (log.f64 base) #s(literal 5/2 binary64))))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
✓	99.3%	#s(approx (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 base))))
	50.8%	#s(approx (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) #s(approx (+ (* (/ 1/2 (log base)) (* (/ re im) (/ re im))) (/ (log im) (log base))) (/.f64 (/.f64 (fma.f64 (.f64 im im) (log.f64 im) (.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 base)) (.f64 im im))))
	2.9%	#s(approx (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) #s(approx (+ (* (/ 1/2 (log base)) (* (/ re im) (/ re im))) (/ (log im) (log base))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (.f64 im im) (log.f64 base)))))
	49.7%	#s(approx (/ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (pow (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base)) 2)) #s(approx (+ (* (/ 1/2 (log base)) (* (/ re im) (/ re im))) (/ (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))))
✓	99.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
✓	53.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
✓	98.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))

Compiler

Compiled 2 241 to 727 computations (67.6% saved)

regimes86.0ms (1.3%)

Memory

37.3MiB live, 132.6MiB allocated; 10ms collecting garbage

Counts

46 → 1

Calls

Call 1

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

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

Calls

5 calls:

30.0ms	im
21.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))))
11.0ms	re
11.0ms	base
11.0ms	(log.f64 base)

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes15.0ms (0.2%)

Memory

-6.6MiB live, 38.1MiB allocated; 7ms collecting garbage

Counts

6 → 1

Calls

Call 1

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

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:

2.0ms	(log.f64 base)
2.0ms	im
2.0ms	base
2.0ms	re
2.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.9%	1	`(log.f64 base)`
98.9%	1	`(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))`
98.9%	1	`re`
98.9%	1	`im`
98.9%	1	`base`

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes13.0ms (0.2%)

Memory

-22.2MiB live, 22.3MiB allocated; 17ms collecting garbage

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

Inputs

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

Outputs

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

Calls

5 calls:

8.0ms	base
1.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))))
1.0ms	im
1.0ms	(log.f64 base)
1.0ms	re

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

simplify60.0ms (0.9%)

Memory

5.1MiB live, 67.1MiB allocated; 23ms collecting garbage

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	51	118
1	118	111
2	426	103
3	3451	103

Stop Event

1×	node limit

Calls

Call 1

Inputs

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

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

Outputs

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

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

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

derivations170.0ms (2.5%)

Memory

17.6MiB live, 154.5MiB allocated; 16ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 134 to 52 computations (61.2% saved)

preprocess84.0ms (1.2%)

Memory

-37.0MiB live, 61.5MiB allocated; 13ms collecting garbage

Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 540 to 278 computations (48.5% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze223.0ms (3.3%)

sample1.9s (27.8%)

explain387.0ms (5.7%)

preprocess191.0ms (2.8%)

eval0.0ms (0%)

prune1.0ms (0%)

series192.0ms (2.8%)

simplify240.0ms (3.6%)

rewrite72.0ms (1.1%)

eval91.0ms (1.3%)

prune72.0ms (1.1%)

series287.0ms (4.2%)

simplify490.0ms (7.3%)

rewrite73.0ms (1.1%)

eval119.0ms (1.8%)

prune68.0ms (1%)

series856.0ms (12.7%)

simplify275.0ms (4.1%)

rewrite42.0ms (0.6%)

eval162.0ms (2.4%)

prune30.0ms (0.4%)

series189.0ms (2.8%)

simplify234.0ms (3.5%)

rewrite42.0ms (0.6%)

eval79.0ms (1.2%)

prune32.0ms (0.5%)

regimes86.0ms (1.3%)

regimes15.0ms (0.2%)

regimes13.0ms (0.2%)

simplify60.0ms (0.9%)

derivations170.0ms (2.5%)

preprocess84.0ms (1.2%)

end0.0ms (0%)

Profiling