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

start0.0ms (0%)

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

analyze291.0ms (4.6%)

Memory

42.0MiB live, 507.0MiB allocated; 187ms 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.8s (29%)

Memory

45.4MiB live, 2 798.4MiB allocated; 485ms collecting garbage

Samples

1.3s

8 256×

valid

Precisions

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

ival-log: 243.0ms (24.5% of total)

ival-hypot: 238.0ms (24% of total)

ival-mult: 213.0ms (21.5% of total)

ival-div: 113.0ms (11.4% of total)

ival-atan2: 89.0ms (9% of total)

ival-add: 83.0ms (8.4% of total)

exact: 6.0ms (0.6% of total)

adjust: 3.0ms (0.3% of total)

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

Bogosity

explain318.0ms (5%)

Memory

-27.8MiB live, 589.2MiB allocated; 127ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
118	-	-	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	-	`(log.f64 base)`
0	-	-	`(*.f64 re re)`
0	-	-	`(atan2.f64 im re)`
0	-	-	`im`
0	-	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	-	`re`
0	-	-	`(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))`
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	-	-	`(/.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	-	-	`#s(literal 0 binary64)`
0	-	-	`(*.f64 (atan2.f64 im re) #s(literal 0 binary64))`
0	-	-	`(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))`
0	-	-	`(*.f64 (log.f64 base) (log.f64 base))`
0	-	-	`(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))`
0	-	-	`(*.f64 im im)`
0	-	-	`base`
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	101	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	101
↳	`(*.f64 re re)`	overflow	63
↳	`(*.f64 im im)`	overflow	52
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	17	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	17
↳	`(*.f64 re re)`	underflow	60
↳	`(*.f64 im im)`	underflow	73

Confusion

	Predicted +	Predicted -
+	118	0
-	0	138

Precision

1.0

Recall

1.0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	118	0	0
-	0	0	138

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	138
1	118

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

106.0ms

512×

valid

Compiler

Compiled 270 to 58 computations (78.5% saved)

Precisions

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

ival-mult: 36.0ms (49.3% of total)

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

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

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

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

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

ival-true: 1.0ms (1.4% of total)

exact: 1.0ms (1.4% of total)

adjust: 0.0ms (0% of total)

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

preprocess137.0ms (2.1%)

Memory

15.3MiB live, 256.6MiB allocated; 15ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	79	209
1	236	189
2	1254	142
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 re)

(abs im)

(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

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

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	54.9%	(/.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

▶

54.9%

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

series193.0ms (3%)

Memory

23.8MiB live, 260.0MiB allocated; 23ms 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
122.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))
28.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re 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))
6.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))
4.0ms	im	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))

rewrite188.0ms (3%)

Memory

10.0MiB live, 288.6MiB allocated; 39ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

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

Stop Event

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

Counts

166 → 383

Calls

Call 1

Inputs
(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (*.f64 im im)))) (log.f64 base))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(log.f64 base)
base
(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
(atan2.f64 im re)
#s(literal 0 binary64)
(+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log im) (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))) (/ (log im) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log base)))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log base)))) (* 1/4 (/ 1 (* (pow im 4) (log base)))))) (* 1/2 (/ 1 (* (pow im 2) (log base)))))) (/ (log im) (log base)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log im))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (* (log base) (log im))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))) (* (log base) (log im)))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* (log base) (log im)) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow im 4))) (* 1/2 (/ (log base) (pow im 2))))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* (log base) (log im)) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow im 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow im 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (* (atan2 im re) 0) #s(hole binary64 0))
#s(approx (atan2 im re) #s(hole binary64 (atan2 im re)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 re))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 re))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ -1 re))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (* -1 (* (log base) (log (/ -1 re))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log re) (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))) (/ (log re) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log base)))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log base)))) (* 1/4 (/ 1 (* (pow re 4) (log base)))))) (* 1/2 (/ 1 (* (pow re 2) (log base)))))) (/ (log re) (log base)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log re))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (* (log base) (log re))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))) (* (log base) (log re)))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* (log base) (log re)) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow re 4))) (* 1/2 (/ (log base) (pow re 2))))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* (log base) (log re)) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow re 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow re 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 im))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ -1 im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (* -1 (* (log base) (log (/ -1 im))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (* (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))))
#s(approx (log base) #s(hole binary64 (log base)))
#s(approx base #s(hole binary64 base))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log base) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (* (log (sqrt (+ (* re re) (* im im)))) (log base)) #s(hole binary64 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (+ (log -1) (* -1 (log (/ -1 base)))))))
#s(approx (log base) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 base))))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))
#s(approx (* (log base) (log base)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 base)))) 2)))

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

eval74.0ms (1.2%)

Memory: -2.6MiB live, 97.8MiB allocated; 12ms collecting garbage
Compiler: Compiled 12 863 to 1 735 computations (86.5% saved)

prune68.0ms (1.1%)

Memory

3.6MiB live, 50.3MiB allocated; 7ms collecting garbage

Pruning

15 alts after pruning (15 fresh and 0 done)

	Pruned	Kept	Total
New	343	15	358
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	344	15	359

Accuracy

99.7%

Counts

359 → 15

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.0%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))))
	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	27.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	3.6%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
	26.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
▶	27.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))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	27.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (exp.f64 (.f64 (log.f64 im) #s(literal 2 binary64)))))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.4%	(/.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.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
▶	98.6%	#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 948 to 634 computations (33.1% saved)

series354.0ms (5.6%)

Memory

-35.2MiB live, 578.9MiB allocated; 202ms collecting garbage

Counts

41 → 391

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

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

Calls

9 calls:

Time	Variable		Point	Expression
94.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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (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) (* im im) (* (atan2 im re) 0) (atan2 im re) 0 (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0))) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0)) (* (log base) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1))
83.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (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) (* im im) (* (atan2 im re) 0) (atan2 im re) 0 (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0))) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0)) (* (log base) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1))
58.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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (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) (* im im) (* (atan2 im re) 0) (atan2 im re) 0 (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0))) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0)) (* (log base) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1))
51.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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (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) (* im im) (* (atan2 im re) 0) (atan2 im re) 0 (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0))) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0)) (* (log base) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1))
25.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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (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) (* im im) (* (atan2 im re) 0) (atan2 im re) 0 (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0))) (+ (* (log base) (exp (* (log (log base)) 1))) (* 0 0)) (* (log base) (exp (* (log (log base)) 1))) (exp (* (log (log base)) 1)) (* (log (log base)) 1))

rewrite276.0ms (4.3%)

Memory

49.9MiB live, 378.3MiB allocated; 47ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	835	15486
0	898	11699
1	3353	11587
0	8973	11015

Stop Event

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

Counts

432 → 996

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

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

eval113.0ms (1.8%)

Memory: -28.7MiB live, 258.0MiB allocated; 68ms collecting garbage
Compiler: Compiled 34 110 to 2 791 computations (91.8% saved)

prune136.0ms (2.1%)

Memory

47.0MiB live, 169.9MiB allocated; 28ms collecting garbage

Pruning

24 alts after pruning (22 fresh and 2 done)

	Pruned	Kept	Total
New	842	14	856
Fresh	2	8	10
Picked	3	2	5
Done	0	0	0
Total	847	24	871

Accuracy

99.9%

Counts

871 → 24

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.0%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.1%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	51.8%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	27.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	27.5%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal 2 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	27.1%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	54.8%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
▶	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))))
	54.8%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
	3.6%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
▶	26.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	27.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (exp.f64 (.f64 (log.f64 im) #s(literal 2 binary64)))))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	51.4%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	51.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	98.4%	(/.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))))
▶	55.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)))
✓	99.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
	51.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
	98.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
	51.8%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))))
✓	98.6%	#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)))
	51.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base)))))

Compiler

Compiled 1 578 to 1 059 computations (32.9% saved)

series507.0ms (8%)

Memory

-29.0MiB live, 926.8MiB allocated; 225ms collecting garbage

Counts

55 → 617

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
136.0ms	base	@	inf	((/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) base (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re 3 0 (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 2 (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log base)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log im) (log base)) (log im) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (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)) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (pow (log base) 2) 0) (pow (log base) 2))
103.0ms	im	@	inf	((/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) base (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re 3 0 (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 2 (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log base)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log im) (log base)) (log im) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (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)) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (pow (log base) 2) 0) (pow (log base) 2))
83.0ms	base	@	0	((/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) base (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re 3 0 (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 2 (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log base)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log im) (log base)) (log im) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (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)) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (pow (log base) 2) 0) (pow (log base) 2))
72.0ms	base	@	-inf	((/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) base (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re 3 0 (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 2 (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log base)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log im) (log base)) (log im) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (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)) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (pow (log base) 2) 0) (pow (log base) 2))
28.0ms	im	@	0	((/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log base) base (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re 3 0 (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 2 (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log base)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log im) (log base)) (log im) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (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)) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0))) (/ (- (pow (log base) 4) 0) (- (pow (log base) 2) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (pow (log base) 2) 0) (pow (log base) 2))

rewrite318.0ms (5%)

Memory

8.3MiB live, 438.3MiB allocated; 58ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1569	28674
0	1668	21857
1	7704	21857
0	8465	20847

Stop Event

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

Counts

672 → 1 152

Calls

Call 1

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

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

eval184.0ms (2.9%)

Memory: 29.0MiB live, 302.9MiB allocated; 58ms collecting garbage
Compiler: Compiled 51 858 to 4 109 computations (92.1% saved)

prune477.0ms (7.5%)

Memory

-120.8MiB live, 120.6MiB allocated; 810ms collecting garbage

Pruning

27 alts after pruning (23 fresh and 4 done)

	Pruned	Kept	Total
New	942	9	951
Fresh	3	14	17
Picked	3	2	5
Done	0	2	2
Total	948	27	975

Accuracy

100.0%

Counts

975 → 27

Alt Table

Click to see full alt table

Status	Accuracy	Program
	99.0%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) (pow.f64 (log.f64 base) #s(literal 2 binary64)) (.f64 (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.0%	(/.f64 (pow.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 3 binary64)) (.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	98.6%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (pow.f64 (log.f64 (hypot.f64 re im)) #s(literal 2 binary64)) (pow.f64 (log.f64 base) #s(literal 2 binary64)) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.0%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (/.f64 (+.f64 (pow.f64 (pow.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (pow.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (pow.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.6%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))))) (/.f64 (-.f64 (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.3%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) #s(literal 0 binary64)) #s(approx (+ (pow ( (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow.f64 (.f64 (log.f64 im) (log.f64 base)) #s(literal 2 binary64)))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.8%	(/.f64 (/.f64 (.f64 (pow.f64 (log.f64 (hypot.f64 re im)) #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 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	27.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	27.5%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal 2 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	27.1%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	54.8%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
	54.8%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
	3.6%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
	27.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.4%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (*.f64 (log.f64 im) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	51.4%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	45.7%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
✓	51.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
▶	99.0%	(*.f64 (/.f64 (fma.f64 (log.f64 (hypot.f64 re im)) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	55.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)))
✓	99.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
	51.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
▶	98.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
	51.8%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))))
✓	98.6%	#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)))
	51.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base)))))

Compiler

Compiled 1 828 to 1 176 computations (35.7% saved)

series209.0ms (3.3%)

Memory

49.3MiB live, 332.9MiB allocated; 41ms collecting garbage

Counts

50 → 655

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
45.0ms	base	@	inf	((/ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2))) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base 3 (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2)) (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 2 0 (pow (log base) 2) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (/ 1 (pow (log base) -1))) (log im) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (* (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4) 4 (/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log im) (log base)) 2) (* (log im) (log base)))
37.0ms	im	@	-inf	((/ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2))) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base 3 (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2)) (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 2 0 (pow (log base) 2) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (/ 1 (pow (log base) -1))) (log im) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (* (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4) 4 (/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log im) (log base)) 2) (* (log im) (log base)))
27.0ms	base	@	0	((/ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2))) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base 3 (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2)) (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 2 0 (pow (log base) 2) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (/ 1 (pow (log base) -1))) (log im) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (* (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4) 4 (/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log im) (log base)) 2) (* (log im) (log base)))
27.0ms	base	@	-inf	((/ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2))) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base 3 (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2)) (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 2 0 (pow (log base) 2) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (/ 1 (pow (log base) -1))) (log im) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (* (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4) 4 (/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log im) (log base)) 2) (* (log im) (log base)))
19.0ms	im	@	inf	((/ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2))) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 3) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base 3 (* (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2)) (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 2 0 (pow (log base) 2) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (/ 1 (pow (log base) -1))) (log im) (/ 1 (pow (log base) -1)) 1 (pow (log base) -1) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (* (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (pow (log base) 2)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4) 4 (/ (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (* (log base) (log base)) (* 0 0))) (/ (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 3) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (- 0 (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) (pow (* (log im) (log base)) 2) (* (log im) (log base)))

rewrite268.0ms (4.2%)

Memory

7.1MiB live, 379.6MiB allocated; 68ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1675	32182
0	1753	26089
0	8189	25136

Stop Event

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

Counts

705 → 1 045

Calls

Call 1

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

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

eval122.0ms (1.9%)

Memory: 6.8MiB live, 192.9MiB allocated; 32ms collecting garbage
Compiler: Compiled 41 937 to 3 456 computations (91.8% saved)

prune53.0ms (0.8%)

Memory

-11.5MiB live, 132.2MiB allocated; 19ms collecting garbage

Pruning

26 alts after pruning (22 fresh and 4 done)

	Pruned	Kept	Total
New	900	14	914
Fresh	10	8	18
Picked	5	0	5
Done	0	4	4
Total	915	26	941

Accuracy

100.0%

Counts

941 → 26

Alt Table

Click to see full alt table

Status	Accuracy	Program
	97.9%	(/.f64 (pow.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 3 binary64)) #s(approx ( (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow (log base) 2)) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64)))))
	98.3%	(/.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (hypot.f64 im re))) #s(literal 3 binary64)) (.f64 #s(approx (+ (pow (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 2) 0) (pow.f64 (*.f64 (log.f64 im) (log.f64 base)) #s(literal 2 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64))))
	99.1%	(/.f64 (+.f64 (/.f64 (.f64 (log.f64 (hypot.f64 im re)) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	54.9%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	27.3%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))))) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	54.8%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) #s(literal -2 binary64)))
	54.8%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
	98.4%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (*.f64 (log.f64 im) (log.f64 base))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	51.4%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	45.7%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
✓	51.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	98.5%	(.f64 (/.f64 (fma.f64 (log.f64 (hypot.f64 re im)) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 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))))))
	99.0%	(.f64 (/.f64 (fma.f64 (log.f64 (hypot.f64 re im)) (log.f64 base) #s(literal 0 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)))
	98.3%	(.f64 (/.f64 (fma.f64 (log.f64 #s(approx (sqrt (+ ( im im) (* re re))) im)) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	99.2%	(.f64 #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (/.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
	98.5%	(.f64 #s(approx (/ (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (pow (log base) 4)) (/.f64 (log.f64 im) (pow.f64 (log.f64 base) #s(literal 3 binary64)))) (pow.f64 (log.f64 base) #s(literal 2 binary64)))
✓	55.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)))
✓	99.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 base)))
	51.1%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
	98.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	51.8%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) (pow.f64 (log.f64 base) #s(literal -1/2 binary64))))))
	51.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal -1 binary64))))))
	51.8%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (*.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)))))
✓	98.6%	#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)))
	51.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base)))))
	98.6%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (/.f64 (log.f64 im) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal -1 binary64))))

Compiler

Compiled 2 794 to 900 computations (67.8% saved)

regimes79.0ms (1.2%)

Memory

-15.6MiB live, 183.1MiB allocated; 24ms collecting garbage

Counts

53 → 1

Calls

Call 1

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

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

Calls

5 calls:

19.0ms	im
16.0ms	base
14.0ms	re
14.0ms	(log.f64 base)
12.0ms	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

regimes8.0ms (0.1%)

Memory

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

Accuracy

Total -28.1b remaining (-3147.9%)

Threshold costs -28.1b (-3147.9%)

Counts

3 → 1

Calls

Call 1

Inputs

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

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

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

Calls

5 calls:

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

Results

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

Compiler

Compiled 33 to 31 computations (6.1% saved)

simplify72.0ms (1.1%)

Memory

-31.9MiB live, 66.3MiB allocated; 12ms collecting garbage

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	26	54
1	63	50
2	241	42
3	1864	38
4	6433	38

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

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

derivations50.0ms (0.8%)

Memory

-8.3MiB live, 36.6MiB allocated; 6ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 70 to 26 computations (62.9% saved)

preprocess20.0ms (0.3%)

Memory

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

Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 412 to 226 computations (45.1% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze291.0ms (4.6%)

sample1.8s (29%)

explain318.0ms (5%)

preprocess137.0ms (2.1%)

eval0.0ms (0%)

prune1.0ms (0%)

series193.0ms (3%)

rewrite188.0ms (3%)

eval74.0ms (1.2%)

prune68.0ms (1.1%)

series354.0ms (5.6%)

rewrite276.0ms (4.3%)

eval113.0ms (1.8%)

prune136.0ms (2.1%)

series507.0ms (8%)

rewrite318.0ms (5%)

eval184.0ms (2.9%)

prune477.0ms (7.5%)

series209.0ms (3.3%)

rewrite268.0ms (4.2%)

eval122.0ms (1.9%)

prune53.0ms (0.8%)

regimes79.0ms (1.2%)

regimes8.0ms (0.1%)

simplify72.0ms (1.1%)

derivations50.0ms (0.8%)

preprocess20.0ms (0.3%)

end0.0ms (0%)

Profiling