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

start0.0ms (0%)

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

analyze235.0ms (5.1%)

Memory

17.6MiB live, 247.1MiB allocated; 63ms 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.7s (36.3%)

Memory

20.5MiB live, 1 684.0MiB allocated; 479ms collecting garbage

Samples

1.3s	8 254×	0	valid
1.0ms	2×	1	valid

Precisions

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

ival-log: 326.0ms (36.8% of total)

ival-hypot: 176.0ms (19.9% of total)

ival-atan2: 136.0ms (15.3% of total)

ival-mult!: 132.0ms (14.9% of total)

ival-div!: 72.0ms (8.1% of total)

ival-add!: 41.0ms (4.6% of total)

adjust: 2.0ms (0.2% of total)

Bogosity

preprocess32.0ms (0.7%)

Memory

-23.5MiB live, 22.5MiB allocated; 4ms collecting garbage

Iterations

Useful iterations: 2 (0.0ms)

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

Stop Event

1×	node-limit

Alt Table

Click to see full alt table

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

Status

Accuracy

Program

▶

53.2%

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

Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 44 to 36 computations (18.2% saved)

series105.0ms (2.3%)

Memory

17.4MiB live, 161.4MiB allocated; 12ms collecting garbage

Counts

18 → 143

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 (* (atan2 im 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 (* -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 (/ (+ (* (log (sqrt (+ (* re 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) (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
48.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
20.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
14.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
3.0ms	re	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
3.0ms	im	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))

rewrite189.0ms (4.1%)

Memory

2.5MiB live, 183.4MiB allocated; 21ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	536	5492
0	559	4906
1	2880	4874
0	8230	3950

Stop Event

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

Counts

161 → 378

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

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

eval37.0ms (0.8%)

Memory: 24.1MiB live, 68.8MiB allocated; 6ms collecting garbage
Compiler: Compiled 5 075 to 1 663 computations (67.2% saved)

prune27.0ms (0.6%)

Memory

-23.3MiB live, 77.1MiB allocated; 11ms collecting garbage

Pruning

21 alts after pruning (21 fresh and 0 done)

	Pruned	Kept	Total
New	308	21	329
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	309	21	330

Accuracy

99.8%

Counts

330 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
	53.0%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	51.7%	(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	51.6%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	53.2%	(/.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))))
	27.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 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64)))
	53.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	53.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	28.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) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	3.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
▶	27.7%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))) (.f64 (/.f64 (.f64 (.f64 re re) (log.f64 base)) (.f64 im im)) #s(literal 1/2 binary64)))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	97.9%	(/.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))))
	53.3%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
	10.8%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
▶	98.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) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))))

Compiler

Compiled 1 094 to 934 computations (14.6% saved)

series240.0ms (5.2%)

Memory

-2.9MiB live, 323.5MiB allocated; 60ms collecting garbage

Counts

40 → 276

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
59.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log im) (log base)) (/ (+ (* (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) (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)
58.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log im) (log base)) (/ (+ (* (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) (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)
38.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log im) (log base)) (/ (+ (* (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) (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)
35.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 im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log im) (log base)) (/ (+ (* (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) (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)
16.0ms	im	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log im) (log base)) (/ (+ (* (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) (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)

rewrite185.0ms (4%)

Memory

49.0MiB live, 233.8MiB allocated; 17ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	715	10420
0	773	8613
1	3211	8541
0	8822	8106

Stop Event

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

Counts

316 → 781

Calls

Call 1

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

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

eval70.0ms (1.5%)

Memory: -15.6MiB live, 120.0MiB allocated; 14ms collecting garbage
Compiler: Compiled 8 585 to 2 648 computations (69.2% saved)

prune37.0ms (0.8%)

Memory

12.3MiB live, 67.2MiB allocated; 5ms collecting garbage

Pruning

34 alts after pruning (33 fresh and 1 done)

	Pruned	Kept	Total
New	704	26	730
Fresh	9	7	16
Picked	4	1	5
Done	0	0	0
Total	717	34	751

Accuracy

99.9%

Counts

751 → 34

Alt Table

Click to see full alt table

Status	Accuracy	Program
	53.0%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	51.7%	(/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (-.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	51.6%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.9%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal -2 binary64)))
	48.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (log.f64 base))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	98.9%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	48.7%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	48.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re 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))))
▶	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	48.7%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (exp.f64 (log.f64 (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))))
	28.2%	(/.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.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 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64)))
▶	53.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	53.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	3.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
	27.7%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	0.0%	(/.f64 #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 (neg.f64 im))) (.f64 (/.f64 (.f64 (.f64 re re) (log.f64 base)) (.f64 im im)) #s(literal 1/2 binary64)))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	97.9%	(/.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 (log.f64 base) (log.f64 base)))
	97.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	97.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	48.2%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	47.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	53.3%	#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 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
▶	10.8%	#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)))
	0.0%	#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 (neg.f64 re))) (log.f64 base))))
	0.0%	#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 (neg.f64 im))) (log.f64 base))))
✓	98.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) (log.f64 base)))
	48.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base)))))
	98.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) #s(approx (/ 1 (pow (log base) -1)) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64))))))

Compiler

Compiled 1 768 to 1 538 computations (13% saved)

series274.0ms (5.9%)

Memory

12.3MiB live, 432.6MiB allocated; 45ms collecting garbage

Counts

45 → 292

Calls

Call 1

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

Calls

9 calls:

Time	Variable		Point	Expression
85.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg 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)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 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) (* im im) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (* (log base) (log base)) 0))
43.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg 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)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 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) (* im im) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (* (log base) (log base)) 0))
38.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg 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)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 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) (* im im) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (* (log base) (log base)) 0))
24.0ms	im	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg 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)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 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) (* im im) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (* (log base) (log base)) 0))
16.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 im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg 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)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 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) (* im im) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (pow (log base) 4) 4 (- (* (log base) (log base)) 0))

rewrite192.0ms (4.2%)

Memory

-9.2MiB live, 261.4MiB allocated; 31ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	752	11190
0	820	9018
1	3388	8922
0	8197	8468

Stop Event

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

Counts

337 → 1 005

Calls

Call 1

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

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

eval79.0ms (1.7%)

Memory: -3.8MiB live, 143.9MiB allocated; 23ms collecting garbage
Compiler: Compiled 10 724 to 3 073 computations (71.3% saved)

prune39.0ms (0.8%)

Memory

32.0MiB live, 78.6MiB allocated; 4ms collecting garbage

Pruning

35 alts after pruning (33 fresh and 2 done)

	Pruned	Kept	Total
New	834	19	853
Fresh	14	14	28
Picked	4	1	5
Done	0	1	1
Total	852	35	887

Accuracy

99.9%

Counts

887 → 35

Alt Table

Click to see full alt table

Status	Accuracy	Program
	51.6%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.9%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal -2 binary64)))
	48.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (log.f64 base))))
▶	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
▶	98.9%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	48.7%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
	48.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	48.7%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (exp.f64 (log.f64 (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))))
	28.2%	(/.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))))
	53.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 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	27.5%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))) (-.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	53.1%	(/.f64 (.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
	0.0%	(/.f64 #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 (neg.f64 im))) (.f64 (/.f64 (.f64 (.f64 re re) (log.f64 base)) (.f64 im im)) #s(literal 1/2 binary64)))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	0.0%	(/.f64 #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 (neg.f64 im))))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #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 (neg.f64 im))))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #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 (neg.f64 im))))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
▶	10.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	97.9%	(/.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 (log.f64 base) (log.f64 base)))
	97.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	97.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	48.2%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (.f64 (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 base) #s(literal -1/2 binary64)) #s(literal -1 binary64))) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	47.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	53.0%	(.f64 (/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
	0.0%	#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 (neg.f64 im)))) (log.f64 base)))
	53.3%	#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 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
✓	10.8%	#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)))
	5.1%	#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) (exp.f64 (log.f64 (log.f64 base)))))
▶	0.0%	#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 (neg.f64 re))) (log.f64 base))))
✓	98.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) (log.f64 base)))
	48.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base)))))
	98.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) #s(approx (/ 1 (pow (log base) -1)) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64))))))

Compiler

Compiled 1 854 to 1 642 computations (11.4% saved)

series321.0ms (7%)

Memory

-56.6MiB live, 360.1MiB allocated; 138ms collecting garbage

Counts

33 → 283

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
104.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (/ (neg (log (neg re))) (log base))) (/ (neg (log (neg re))) (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (/ (pow (log base) 4) (* (log base) (log base))) (pow (log base) 4) 4)
73.0ms	re	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (/ (neg (log (neg re))) (log base))) (/ (neg (log (neg re))) (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (/ (pow (log base) 4) (* (log base) (log base))) (pow (log base) 4) 4)
42.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (/ (neg (log (neg re))) (log base))) (/ (neg (log (neg re))) (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (/ (pow (log base) 4) (* (log base) (log base))) (pow (log base) 4) 4)
35.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (/ (neg (log (neg re))) (log base))) (/ (neg (log (neg re))) (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (/ (pow (log base) 4) (* (log base) (log base))) (pow (log base) 4) 4)
28.0ms	re	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (/ (neg (log (neg re))) (log base))) (/ (neg (log (neg re))) (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ 1 (* (/ 1 (log base)) (/ 1 (log base))))) (/ 1 (* (/ 1 (log base)) (/ 1 (log base)))) 1 (* (/ 1 (log base)) (/ 1 (log base))) (/ 1 (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (/ (pow (log base) 4) (* (log base) (log base))) (pow (log base) 4) 4)

rewrite313.0ms (6.8%)

Memory

26.1MiB live, 347.2MiB allocated; 124ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	728	11027
0	776	8839
1	3313	8739
0	9159	8294

Stop Event

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

Counts

316 → 820

Calls

Call 1

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

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

eval144.0ms (3.1%)

Memory: 2.6MiB live, 195.7MiB allocated; 64ms collecting garbage
Compiler: Compiled 15 333 to 3 068 computations (80% saved)

prune71.0ms (1.5%)

Memory

3.6MiB live, 104.0MiB allocated; 10ms collecting garbage

Pruning

49 alts after pruning (45 fresh and 4 done)

	Pruned	Kept	Total
New	1 114	26	1 140
Fresh	9	19	28
Picked	3	2	5
Done	0	2	2
Total	1 126	49	1 175

Accuracy

100.0%

Counts

1 175 → 49

Alt Table

Click to see full alt table

Status	Accuracy	Program
	53.3%	(/.f64 (/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (log.f64 base)) (log.f64 base))
	51.6%	(/.f64 (/.f64 (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.9%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal -2 binary64)))
	48.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (log.f64 base))))
	98.9%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)))))))
✓	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
	48.7%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (log.f64 base) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))))))
	49.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))))
	48.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))))
	98.6%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (/.f64 (.f64 (-.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))) (.f64 (-.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)) (-.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))) (*.f64 (log.f64 base) (log.f64 base))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 base))))
	47.7%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))) (.f64 (log.f64 base) (log.f64 base))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -2 binary64))))
	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
✓	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
	48.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	48.6%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	53.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 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	53.1%	(/.f64 (.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (pow.f64 (log.f64 base) #s(literal 6 binary64)))
	0.0%	(/.f64 #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 (neg.f64 im))) (.f64 (/.f64 (.f64 (.f64 re re) (log.f64 base)) (.f64 im im)) #s(literal 1/2 binary64)))) (*.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #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 (neg.f64 re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (log.f64 base) (log.f64 base))))
	0.0%	(/.f64 #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 (neg.f64 re))))) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	0.0%	(/.f64 #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 (neg.f64 re))))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #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 (neg.f64 im))))) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	0.0%	(/.f64 #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 (neg.f64 im))))) (+.f64 (.f64 (log.f64 base) (exp.f64 (log.f64 (log.f64 base)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #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 (neg.f64 im))))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #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 (neg.f64 im))))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	10.8%	(/.f64 #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)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (log.f64 base) (log.f64 base))))
	10.8%	(/.f64 #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)))) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	10.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal -2 binary64)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (/.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 base))) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	5.1%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 re) (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))))
	10.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)))
	5.1%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (/ 1 (pow (log base) -1))) (* (atan2 im re) 0)) (.f64 (log.f64 re) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	97.6%	(/.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 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))))
	97.9%	(/.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 (log.f64 base) (log.f64 base)))
	97.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	47.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	53.0%	(.f64 (/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
	53.1%	(.f64 (/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
	0.0%	#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 (neg.f64 im)))) (log.f64 base)))
	53.3%	#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 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
	0.0%	#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 (neg.f64 re)) (log.f64 base)))
✓	10.8%	#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)))
	5.1%	#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) (exp.f64 (log.f64 (log.f64 base)))))
✓	98.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) (log.f64 base)))
	48.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (log.f64 (log.f64 base)))))
	98.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) #s(approx (/ 1 (pow (log base) -1)) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64))))))

Compiler

Compiled 2 464 to 1 495 computations (39.3% saved)

regimes137.0ms (3%)

Memory

-11.6MiB live, 171.1MiB allocated; 25ms collecting garbage

Counts

93 → 1

Calls

Call 1

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

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

Calls

5 calls:

43.0ms	(log.f64 base)
24.0ms	im
23.0ms	base
22.0ms	re
18.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.2%	1	`(log.f64 base)`
99.2%	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.2%	1	`re`
99.2%	1	`im`
99.2%	1	`base`

Compiler

Compiled 27 to 31 computations (-14.8% saved)

regimes43.0ms (0.9%)

Memory

30.6MiB live, 75.1MiB allocated; 4ms collecting garbage

Accuracy

Total -62.8b remaining (-5239.8%)

Threshold costs -62.8b (-5239.8%)

Counts

34 → 1

Calls

Call 1

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

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

Calls

5 calls:

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

Results

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

Compiler

Compiled 27 to 31 computations (-14.8% saved)

derivations129.0ms (2.8%)

Memory

0.0MiB live, 89.7MiB allocated; 10ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 37 to 30 computations (18.9% saved)

preprocess33.0ms (0.7%)

Memory: -33.0MiB live, 60.1MiB allocated; 14ms collecting garbage
Compiler: Compiled 305 to 270 computations (11.5% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze235.0ms (5.1%)

sample1.7s (36.3%)

preprocess32.0ms (0.7%)

series105.0ms (2.3%)

rewrite189.0ms (4.1%)

eval37.0ms (0.8%)

prune27.0ms (0.6%)

series240.0ms (5.2%)

rewrite185.0ms (4%)

eval70.0ms (1.5%)

prune37.0ms (0.8%)

series274.0ms (5.9%)

rewrite192.0ms (4.2%)

eval79.0ms (1.7%)

prune39.0ms (0.8%)

series321.0ms (7%)

rewrite313.0ms (6.8%)

eval144.0ms (3.1%)

prune71.0ms (1.5%)

regimes137.0ms (3%)

regimes43.0ms (0.9%)

derivations129.0ms (2.8%)

preprocess33.0ms (0.7%)

end0.0ms (0%)

Profiling