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

start0.0ms (0%)

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

analyze123.0ms (3.7%)

Memory

7.5MiB live, 39.2MiB allocated; 1ms 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.2s (35.6%)

Memory

-48.3MiB live, 301.8MiB allocated; 142ms collecting garbage

Samples

671.0ms

8 256×

valid

Precisions

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

ival-log: 155.0ms (31.9% of total)

ival-hypot: 125.0ms (25.7% of total)

ival-mult!: 89.0ms (18.3% of total)

ival-atan2: 53.0ms (10.9% of total)

ival-add!: 33.0ms (6.8% of total)

ival-div!: 30.0ms (6.2% of total)

adjust: 1.0ms (0.2% of total)

Bogosity

preprocess30.0ms (0.9%)

Memory

3.7MiB live, 3.7MiB allocated; 0ms 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
▶	48.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

▶

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

series96.0ms (2.9%)

Memory

1.3MiB live, 45.2MiB allocated; 8ms collecting garbage

Counts

18 → 148

Calls

Call 1

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

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

Calls

9 calls:

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

rewrite158.0ms (4.8%)

Memory

0.5MiB live, 53.4MiB allocated; 10ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	541	5513
0	565	4927
1	2886	4895
0	8235	3971

Stop Event

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

Counts

166 → 383

Calls

Call 1

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

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

eval40.0ms (1.2%)

Memory: 2.4MiB live, 27.5MiB allocated; 9ms collecting garbage
Compiler: Compiled 5 110 to 1 680 computations (67.1% saved)

prune14.0ms (0.4%)

Memory

-2.5MiB live, 13.3MiB allocated; 0ms collecting garbage

Pruning

17 alts after pruning (17 fresh and 0 done)

	Pruned	Kept	Total
New	307	17	324
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	308	17	325

Accuracy

99.7%

Counts

325 → 17

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	48.1%	(/.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)))
	48.2%	(/.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)))
▶	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))))
	48.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	48.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 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	23.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 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	23.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))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
	23.8%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #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.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.4%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	48.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.6%	#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.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (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 840 to 734 computations (12.6% saved)

series207.0ms (6.2%)

Memory

1.3MiB live, 142.8MiB allocated; 19ms collecting garbage

Counts

37 → 329

Calls

Call 1

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

Calls

9 calls:

Time	Variable		Point	Expression
37.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 (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (* (log base) (log base)) 0) (pow (log base) 4) 4)
32.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 (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (* (log base) (log base)) 0) (pow (log base) 4) 4)
32.0ms	re	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (* (log base) (log base)) 0) (pow (log base) 4) 4)
28.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (* (log base) (log base)) 0) (pow (log base) 4) 4)
17.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 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 (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (* (log base) (log base)) 0) (pow (log base) 4) 4)

rewrite169.0ms (5.1%)

Memory

6.4MiB live, 58.2MiB allocated; 5ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	861	11981
0	924	9742
1	3997	9581
0	8579	9125

Stop Event

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

Counts

366 → 735

Calls

Call 1

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

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

eval57.0ms (1.7%)

Memory: 1.0MiB live, 41.1MiB allocated; 9ms collecting garbage
Compiler: Compiled 8 104 to 2 300 computations (71.6% saved)

prune26.0ms (0.8%)

Memory

0.3MiB live, 24.0MiB allocated; 0ms collecting garbage

Pruning

31 alts after pruning (29 fresh and 2 done)

	Pruned	Kept	Total
New	530	21	551
Fresh	4	8	12
Picked	3	2	5
Done	0	0	0
Total	537	31	568

Accuracy

99.8%

Counts

568 → 31

Alt Table

Click to see full alt table

Status	Accuracy	Program
	48.1%	(/.f64 (fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 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)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
	48.1%	(/.f64 (fma.f64 (.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (log.f64 base)) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	48.1%	(/.f64 (fma.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	48.1%	(/.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 (.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64)))
	48.2%	(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
	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 (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)) #s(literal 0 binary64))))
	46.0%	(/.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.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
▶	23.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 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	48.1%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	10.6%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	98.3%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 4 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 (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))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (exp.f64 (.f64 (log.f64 (neg.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)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (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)) (.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.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	98.4%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64))) (neg.f64 (log.f64 (neg.f64 re))))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
✓	48.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)))
	23.8%	#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)))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
▶	10.6%	#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.4%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
✓	98.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
	46.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) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
	98.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (log im) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64)))) (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 529 to 1 347 computations (11.9% saved)

series257.0ms (7.7%)

Memory

1.4MiB live, 159.3MiB allocated; 27ms collecting garbage

Counts

43 → 268

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
84.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (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 im) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log im)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2)
44.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (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 im) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log im)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2)
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)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log im) (log base)) (log im) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log im)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2)
14.0ms	im	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (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 im) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log im)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2)
13.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 im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (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 im) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log im)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (exp (* (log (neg (log base))) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (* im im) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) (neg (log base)) 2)

rewrite170.0ms (5.1%)

Memory

4.8MiB live, 57.3MiB allocated; 8ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	810	10181
0	865	8208
1	3963	8043
0	8627	7644

Stop Event

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

Counts

311 → 747

Calls

Call 1

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

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

eval57.0ms (1.7%)

Memory: 0.0MiB live, 39.5MiB allocated; 10ms collecting garbage
Compiler: Compiled 7 631 to 2 464 computations (67.7% saved)

prune27.0ms (0.8%)

Memory

-0.8MiB live, 24.2MiB allocated; 2ms collecting garbage

Pruning

34 alts after pruning (30 fresh and 4 done)

	Pruned	Kept	Total
New	528	14	542
Fresh	8	16	24
Picked	3	2	5
Done	0	2	2
Total	539	34	573

Accuracy

99.9%

Counts

573 → 34

Alt Table

Click to see full alt table

Status	Accuracy	Program
	48.1%	(/.f64 (fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 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)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
	48.1%	(/.f64 (fma.f64 (.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (log.f64 base)) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	48.1%	(/.f64 (fma.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	48.2%	(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base) #s(literal 0 binary64)) (.f64 (log.f64 base) (log.f64 base)))
	23.7%	(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base) #s(literal 0 binary64)) (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	51.2%	(/.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 (neg.f64 (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 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #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)))
	46.0%	(/.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.1%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	10.6%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	98.0%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 im))) (pow.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64)))
✓	98.3%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	98.3%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 base)) (log.f64 base)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 4 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 (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))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (exp.f64 (.f64 (log.f64 (neg.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)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (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)) (.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.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	98.3%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (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))))
	98.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 (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))))
	98.4%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64))) (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%	#s(approx (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))))
▶	0.0%	#s(approx (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))))
✓	48.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)))
	23.8%	#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)))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
✓	10.6%	#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)))
	5.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
✓	98.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
	46.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) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
	98.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (log im) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64)))) (log.f64 base)))

Compiler

Compiled 1 667 to 1 463 computations (12.2% saved)

series220.0ms (6.6%)

Memory

-2.7MiB live, 181.0MiB allocated; 13ms collecting garbage

Counts

41 → 311

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

Calls

9 calls:

Time	Variable		Point	Expression
40.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 base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0))
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 base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0))
34.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 base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0))
20.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 base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0))
20.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 base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg (/ (neg (log (neg im))) (log base))) (/ (neg (log (neg im))) (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0) (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (* (pow (log base) 3) (log re)) (pow (log base) 3) 3 (pow (log base) 4) 4 (/ (+ (* (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)) (* (neg (log base)) (neg (log (neg re)))) (neg (log base)) (neg (log (neg re))) (log (neg re)) (neg re) (/ (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0)) (- (pow (log base) 4) 0) (- (* (log base) (log base)) 0))

rewrite177.0ms (5.3%)

Memory

7.1MiB live, 59.5MiB allocated; 9ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	870	11998
0	929	9492
1	4138	9279
0	8878	8832

Stop Event

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

Counts

352 → 798

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

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

eval55.0ms (1.6%)

Memory: 5.6MiB live, 42.1MiB allocated; 6ms collecting garbage
Compiler: Compiled 8 301 to 2 607 computations (68.6% saved)

prune37.0ms (1.1%)

Memory

0.6MiB live, 33.7MiB allocated; 1ms collecting garbage

Pruning

43 alts after pruning (37 fresh and 6 done)

	Pruned	Kept	Total
New	604	16	620
Fresh	4	21	25
Picked	3	2	5
Done	0	4	4
Total	611	43	654

Accuracy

99.9%

Counts

654 → 43

Alt Table

Click to see full alt table

Status	Accuracy	Program
	48.1%	(/.f64 (fma.f64 (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 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)) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
	48.1%	(/.f64 (fma.f64 (.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (log.f64 base)) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	48.1%	(/.f64 (fma.f64 (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	23.7%	(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base) #s(literal 0 binary64)) (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	51.2%	(/.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 (neg.f64 (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 (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)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 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)))
	46.0%	(/.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.1%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	10.6%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 re))) (pow.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64)))
✓	10.6%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	10.6%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 re))) (/.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))))))
	98.0%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 im))) (pow.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64)))
✓	98.3%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (*.f64 (pow.f64 (log.f64 base) #s(literal 3 binary64)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	10.6%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 base)) (log.f64 base)) (log.f64 re))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	98.3%	(/.f64 #s(approx (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (.f64 (.f64 (*.f64 (log.f64 base) (log.f64 base)) (log.f64 base)) (log.f64 im))) (pow.f64 (log.f64 base) #s(literal 4 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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #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))) #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 (/.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))))) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #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 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (exp.f64 (.f64 (log.f64 (neg.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)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (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)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (.f64 (log.f64 base) (log.f64 base)))
	48.2%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (log.f64 base))) (*.f64 (log.f64 base) (log.f64 base)))
	10.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (log.f64 base) (log.f64 base))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	5.1%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	10.6%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)))
	98.3%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (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))))
	98.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 (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))))
	98.4%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64))) (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 (/.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))))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))))
	0.0%	#s(approx (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))))))
	0.0%	#s(approx (/ (+ (* (* (log base) (log (sqrt (+ (* im im) (* re re))))) (* (log base) (log base))) (* (* (log base) (log base)) 0)) (pow (log base) 4)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))))))
✓	48.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)))
	23.8%	#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)))) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
✓	10.6%	#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)))
	5.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
✓	98.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
	46.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) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
	98.5%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(approx (log im) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64)))) (log.f64 base)))

Compiler

Compiled 2 024 to 1 282 computations (36.7% saved)

regimes90.0ms (2.7%)

Memory

-4.5MiB live, 38.1MiB allocated; 12ms collecting garbage

Counts

69 → 1

Calls

Call 1

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

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

Calls

5 calls:

26.0ms	re
16.0ms	(log.f64 base)
15.0ms	im
15.0ms	base
14.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)

regimes34.0ms (1%)

Memory

-6.8MiB live, 18.9MiB allocated; 0ms collecting garbage

Accuracy

Total -63.1b remaining (-6791.9%)

Threshold costs -63.1b (-6791.9%)

Counts

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

7.0ms	base
7.0ms	re
7.0ms	im
7.0ms	(log.f64 base)
6.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.5%	1	`(log.f64 base)`
98.5%	1	`(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))`
98.5%	1	`re`
98.5%	1	`im`
98.5%	1	`base`

Compiler

Compiled 27 to 31 computations (-14.8% saved)

derivations81.0ms (2.4%)

Memory

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

Stop Event

1×

fuel

Compiler

Compiled 37 to 30 computations (18.9% saved)

preprocess22.0ms (0.7%)

Memory: 3.5MiB live, 18.8MiB allocated; 1ms 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%)

analyze123.0ms (3.7%)

sample1.2s (35.6%)

preprocess30.0ms (0.9%)

series96.0ms (2.9%)

rewrite158.0ms (4.8%)

eval40.0ms (1.2%)

prune14.0ms (0.4%)

series207.0ms (6.2%)

rewrite169.0ms (5.1%)

eval57.0ms (1.7%)

prune26.0ms (0.8%)

series257.0ms (7.7%)

rewrite170.0ms (5.1%)

eval57.0ms (1.7%)

prune27.0ms (0.8%)

series220.0ms (6.6%)

rewrite177.0ms (5.3%)

eval55.0ms (1.6%)

prune37.0ms (1.1%)

regimes90.0ms (2.7%)

regimes34.0ms (1%)

derivations81.0ms (2.4%)

preprocess22.0ms (0.7%)

end0.0ms (0%)

Profiling