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

start0.0ms (0%)

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

analyze223.0ms (4.1%)

Memory

-32.6MiB live, 443.6MiB allocated; 118ms collecting garbage

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.9%	0.1%	0%	0%	0%	0
0%	0%	99.9%	0.1%	0%	0%	0%	1
0%	0%	99.9%	0.1%	0%	0%	0%	2
0%	0%	99.9%	0.1%	0%	0%	0%	3
0%	0%	49.9%	0.1%	0%	49.9%	0%	4
0%	0%	49.9%	0.1%	0%	49.9%	0%	5
0%	0%	49.9%	0.1%	0%	49.9%	0%	6
9.4%	4.7%	45.2%	0.1%	0%	49.9%	0%	7
17.2%	8.6%	41.3%	0.1%	0%	49.9%	0%	8
27.3%	13.7%	36.3%	0.1%	0%	49.9%	0%	9
41%	20.5%	29.4%	0.1%	0%	49.9%	0%	10
48.6%	24.3%	25.6%	0.1%	0%	49.9%	0%	11
57.1%	28.5%	21.4%	0.1%	0%	49.9%	0%	12

Compiler

Compiled 30 to 17 computations (43.3% saved)

sample1.5s (27.4%)

Memory

71.1MiB live, 2 073.3MiB allocated; 664ms collecting garbage

Samples

1.1s

8 256×

valid

Precisions

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

ival-log: 246.0ms (30.5% of total)

ival-hypot: 163.0ms (20.2% of total)

ival-add!: 140.0ms (17.3% of total)

ival-mult!: 124.0ms (15.4% of total)

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

ival-div!: 66.0ms (8.2% of total)

adjust: 2.0ms (0.2% of total)

Bogosity

preprocess98.0ms (1.8%)

Memory

-14.1MiB live, 44.3MiB allocated; 39ms collecting garbage

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	79	197
1	292	177
2	1467	142

Stop Event

1×	node-limit

Alt Table

Click to see full alt table

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

Status

Accuracy

Program

▶

53.7%

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

series110.0ms (2%)

Memory

27.8MiB live, 160.2MiB allocated; 27ms collecting garbage

Counts

18 → 114

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

Calls

9 calls:

Time	Variable		Point	Expression
53.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))
23.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
14.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
3.0ms	re	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
3.0ms	im	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))

rewrite207.0ms (3.8%)

Memory

32.6MiB live, 214.0MiB allocated; 47ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	507	4361
0	530	3832
1	2850	3800
0	8224	3068

Stop Event

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

Counts

132 → 349

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

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

eval476.0ms (8.7%)

Memory: -155.5MiB live, 105.9MiB allocated; 809ms collecting garbage
Compiler: Compiled 4 365 to 1 571 computations (64% saved)

prune14.0ms (0.3%)

Memory

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

Pruning

16 alts after pruning (16 fresh and 0 done)

	Pruned	Kept	Total
New	277	16	293
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	278	16	294

Accuracy

99.7%

Counts

294 → 16

Alt Table

Click to see full alt table

Status	Accuracy	Program
	53.6%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
▶	99.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	53.6%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	53.6%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.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))))))
▶	25.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 (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)))))
	25.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))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
	27.6%	(/.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.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 im) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶	53.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)))) (log.f64 base)))
	10.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
▶	99.2%	#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 826 to 716 computations (13.3% saved)

series400.0ms (7.3%)

Memory

43.1MiB live, 596.0MiB allocated; 104ms collecting garbage

Counts

44 → 173

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

Calls

9 calls:

Time	Variable		Point	Expression
103.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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))
84.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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))
52.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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))
46.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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))
33.0ms	im	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* 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 (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))

rewrite284.0ms (5.2%)

Memory

-22.3MiB live, 261.0MiB allocated; 111ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	729	8106
0	793	6464
1	4106	6297
0	9095	5996

Stop Event

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

Counts

217 → 786

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

eval70.0ms (1.3%)

Memory: 0.7MiB live, 128.9MiB allocated; 37ms collecting garbage
Compiler: Compiled 8 516 to 2 516 computations (70.5% saved)

prune36.0ms (0.7%)

Memory

27.4MiB live, 84.9MiB allocated; 15ms collecting garbage

Pruning

30 alts after pruning (28 fresh and 2 done)

	Pruned	Kept	Total
New	525	18	543
Fresh	1	10	11
Picked	3	2	5
Done	0	0	0
Total	529	30	559

Accuracy

99.9%

Counts

559 → 30

Alt Table

Click to see full alt table

Status	Accuracy	Program
	53.6%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	46.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	99.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 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
▶	99.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	51.8%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re 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))))
	53.6%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))
	53.6%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.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))))))
	25.4%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) #s(approx (sinh ( (log (neg (log base))) 2)) (.f64 (-.f64 (pow.f64 (log.f64 (.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64))) #s(literal 2 binary64)) (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(literal 1/2 binary64)))))
	25.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))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
▶	25.2%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.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)))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (/.f64 #s(literal 1 binary64) (pow.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 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 base)))) (.f64 (log.f64 base) (log.f64 base)))
▶	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (-.f64 (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 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (log.f64 base)))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (+.f64 (.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 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (neg.f64 (log.f64 (neg.f64 re))))) (+.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))))
▶	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
	99.0%	(/.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))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im)))) (.f64 #s(literal 1/2 binary64) (fma.f64 #s(literal 2 binary64) (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (.f64 #s(literal 2 binary64) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))))))
✓	53.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)))) (log.f64 base)))
	27.7%	#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.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
	99.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) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
✓	99.2%	#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))))
	51.0%	#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 base) (/.f64 (neg.f64 (log.f64 im)) (.f64 #s(literal 1/2 binary64) (fma.f64 #s(literal 2 binary64) (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (.f64 #s(literal 2 binary64) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))))))))

Compiler

Compiled 1 635 to 1 429 computations (12.6% saved)

series365.0ms (6.7%)

Memory

5.7MiB live, 472.9MiB allocated; 62ms collecting garbage

Counts

46 → 178

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

Calls

9 calls:

Time	Variable		Point	Expression
102.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 re) (log base)) (/ (+ (* (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) (pow (log base) 4) 4 (- (* (log base) (log base)) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (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) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))
73.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 re) (log base)) (/ (+ (* (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) (pow (log base) 4) 4 (- (* (log base) (log base)) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (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) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))
60.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 re) (log base)) (/ (+ (* (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) (pow (log base) 4) 4 (- (* (log base) (log base)) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (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) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))
57.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 re) (log base)) (/ (+ (* (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) (pow (log base) 4) 4 (- (* (log base) (log base)) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (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) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))
29.0ms	re	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (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 (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) (pow (log base) 4) 4 (- (* (log base) (log base)) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (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) (+ (cosh (* (log (neg (log base))) 2)) (sinh (* (log (neg (log base))) 2))) (cosh (* (log (neg (log base))) 2)) (* (log (neg (log base))) 2) (log (neg (log base))) 2 (sinh (* (log (neg (log base))) 2)))

rewrite262.0ms (4.8%)

Memory

-5.0MiB live, 328.9MiB allocated; 76ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	742	8202
0	809	6542
1	4210	6383
0	9330	6077

Stop Event

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

Counts

224 → 867

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

eval64.0ms (1.2%)

Memory: 15.2MiB live, 162.8MiB allocated; 18ms collecting garbage
Compiler: Compiled 9 065 to 2 662 computations (70.6% saved)

prune56.0ms (1%)

Memory

-35.8MiB live, 56.5MiB allocated; 7ms collecting garbage

Pruning

30 alts after pruning (27 fresh and 3 done)

	Pruned	Kept	Total
New	562	13	575
Fresh	9	14	23
Picked	4	1	5
Done	0	2	2
Total	575	30	605

Accuracy

99.9%

Counts

605 → 30

Alt Table

Click to see full alt table

Status	Accuracy	Program
	53.6%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
	99.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 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
▶	99.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
	51.8%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (.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))))
	25.4%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) #s(approx (sinh ( (log (neg (log base))) 2)) (.f64 (-.f64 (pow.f64 (log.f64 (.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64))) #s(literal 2 binary64)) (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(literal 1/2 binary64)))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (/.f64 #s(literal 1 binary64) (pow.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 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 base)))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (log.f64 base)))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (+.f64 (.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 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (neg.f64 (log.f64 (neg.f64 re))))) (+.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))))
▶	4.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 re) (log.f64 base))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (log.f64 base) (log.f64 base))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (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)) (+.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)))
	99.0%	(/.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))))
	0.0%	(.f64 (/.f64 #s(approx (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 base)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im)))) (.f64 #s(literal 1/2 binary64) (fma.f64 #s(literal 2 binary64) (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (.f64 #s(literal 2 binary64) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))))))
✓	53.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)))) (log.f64 base)))
	27.7%	#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.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
✓	10.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
	6.1%	#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)))))
	99.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) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
✓	99.2%	#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))))
▶	51.0%	#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 base) (/.f64 (neg.f64 (log.f64 im)) (.f64 #s(literal 1/2 binary64) (fma.f64 #s(literal 2 binary64) (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (.f64 #s(literal 2 binary64) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))))))))

Compiler

Compiled 1 645 to 1 451 computations (11.8% saved)

series643.0ms (11.8%)

Memory

22.7MiB live, 787.4MiB allocated; 83ms collecting garbage

Counts

47 → 179

Calls

Call 1

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

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

Calls

9 calls:

Time	Variable		Point	Expression
125.0ms	base	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (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))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log (neg re))) (neg (log base))) (neg (log (neg re))) (log (neg re)) (neg re) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (exp 2) (log (neg (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (pow (exp 2) (log (neg (log base)))) (exp 2) 2 (log (neg (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))))) (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))))) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))) (neg (log im)) (log im) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))) 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))) (cosh (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (* 2 (sinh (* (log (log base)) 2))) (sinh (* (log (log base)) 2)))
125.0ms	base	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (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))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log (neg re))) (neg (log base))) (neg (log (neg re))) (log (neg re)) (neg re) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (exp 2) (log (neg (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (pow (exp 2) (log (neg (log base)))) (exp 2) 2 (log (neg (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))))) (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))))) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))) (neg (log im)) (log im) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))) 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))) (cosh (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (* 2 (sinh (* (log (log base)) 2))) (sinh (* (log (log base)) 2)))
122.0ms	base	@	0	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (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))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log (neg re))) (neg (log base))) (neg (log (neg re))) (log (neg re)) (neg re) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (exp 2) (log (neg (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (pow (exp 2) (log (neg (log base)))) (exp 2) 2 (log (neg (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))))) (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))))) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))) (neg (log im)) (log im) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))) 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))) (cosh (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (* 2 (sinh (* (log (log base)) 2))) (sinh (* (log (log base)) 2)))
69.0ms	im	@	-inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (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))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log (neg re))) (neg (log base))) (neg (log (neg re))) (log (neg re)) (neg re) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (exp 2) (log (neg (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (pow (exp 2) (log (neg (log base)))) (exp 2) 2 (log (neg (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))))) (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))))) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))) (neg (log im)) (log im) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))) 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))) (cosh (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (* 2 (sinh (* (log (log base)) 2))) (sinh (* (log (log base)) 2)))
67.0ms	im	@	inf	((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (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))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log (neg re))) (neg (log base))) (neg (log (neg re))) (log (neg re)) (neg re) (neg (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (pow (exp 2) (log (neg (log base))))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log re) (log base)) (log re) (pow (exp 2) (log (neg (log base)))) (exp 2) 2 (log (neg (log base))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))))) (* (log base) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))))) (/ (neg (log im)) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))) (neg (log im)) (log im) (* 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2))))) 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))) (cosh (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) (* 2 (sinh (* (log (log base)) 2))) (sinh (* (log (log base)) 2)))

rewrite212.0ms (3.9%)

Memory

17.1MiB live, 296.7MiB allocated; 51ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	696	5495
0	768	4763
1	3568	4509
0	8656	4328

Stop Event

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

Counts

226 → 627

Calls

Call 1

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

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

eval89.0ms (1.6%)

Memory: 23.6MiB live, 155.5MiB allocated; 27ms collecting garbage
Compiler: Compiled 8 349 to 2 932 computations (64.9% saved)

prune47.0ms (0.9%)

Memory

3.5MiB live, 147.5MiB allocated; 22ms collecting garbage

Pruning

32 alts after pruning (27 fresh and 5 done)

	Pruned	Kept	Total
New	588	12	600
Fresh	7	15	22
Picked	3	2	5
Done	0	3	3
Total	598	32	630

Accuracy

99.9%

Counts

630 → 32

Alt Table

Click to see full alt table

Status	Accuracy	Program
	53.6%	(/.f64 (fma.f64 (.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))))) (.f64 (log.f64 base) (log.f64 base)) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
	99.1%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
	99.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 6 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (+.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	99.2%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
✓	99.3%	(/.f64 (+.f64 (.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
	25.4%	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) #s(approx ( (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) #s(approx (sinh ( (log (neg (log base))) 2)) (.f64 (-.f64 (pow.f64 (log.f64 (.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) base)) #s(literal -1 binary64))) #s(literal 2 binary64)) (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(literal 1/2 binary64)))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 (neg.f64 re))) (/.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (log.f64 base)) #s(literal -1 binary64))))) (.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 (neg.f64 re))) (neg.f64 (exp.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))) (.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)))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 (neg.f64 re))) (exp.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64))))) (*.f64 (log.f64 base) (log.f64 base)))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 base) (log.f64 base)))))
	0.0%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (.f64 (log.f64 base) (log.f64 base)))
✓	4.8%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 re) (log.f64 base))) (pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (neg.f64 (log.f64 base)))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (.f64 (log.f64 base) (log.f64 base))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (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)) (+.f64 #s(literal 0 binary64) (.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
	10.9%	(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (log.f64 re) (log.f64 base))) (.f64 (log.f64 base) (log.f64 base)))
	99.0%	(/.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)) #s(approx (* (neg (log (neg re))) (neg (log base))) (.f64 (log.f64 (neg.f64 re)) (log.f64 base)))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	(.f64 (/.f64 #s(approx (+ ( (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 base)))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (.f64 (log.f64 base) (log.f64 base)))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im)))) (.f64 #s(literal 1/2 binary64) (fma.f64 #s(literal 2 binary64) (cosh.f64 (.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (.f64 #s(literal 2 binary64) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))))))
✓	53.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)))) (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))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
	10.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
✓	10.9%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
	6.1%	#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)))))
	99.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) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64)))))
✓	99.2%	#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))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal -1 binary64))))))
	0.0%	#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))))))
	46.0%	#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 base) (/.f64 (neg.f64 (log.f64 im)) (.f64 #s(literal 1/2 binary64) (fma.f64 #s(literal 2 binary64) (cosh.f64 (.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (.f64 #s(literal 2 binary64) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))))))))
	98.8%	#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 base) (/.f64 (neg.f64 (log.f64 im)) (.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 6 binary64)) #s(literal 0 binary64)) #s(literal 4 binary64)) (.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (.f64 (.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))) #s(literal 2 binary64))))))))
	99.0%	#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 base) #s(approx (/ (neg (log im)) ( 1/2 (+ (* 2 (cosh (* (log (log base)) 2))) (* 2 (sinh (* (log (log base)) 2)))))) (/.f64 (neg.f64 (log.f64 im)) (*.f64 (log.f64 base) (log.f64 base)))))))

Compiler

Compiled 1 757 to 1 100 computations (37.4% saved)

regimes101.0ms (1.9%)

Memory

-17.1MiB live, 259.9MiB allocated; 46ms collecting garbage

Counts

60 → 1

Calls

Call 1

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

24.0ms	(log.f64 base)
20.0ms	base
18.0ms	im
18.0ms	re
16.0ms	(/.f64 (+.f64 (.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 base)) (.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (.f64 (log.f64 base) (log.f64 base)) (.f64 #s(literal 0 binary64) #s(literal 0 binary64))))

Results

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

Compiler

Compiled 27 to 31 computations (-14.8% saved)

regimes37.0ms (0.7%)

Memory

22.4MiB live, 113.2MiB allocated; 10ms collecting garbage

Accuracy

Total -63.5b remaining (-12439.6%)

Threshold costs -63.5b (-12439.6%)

Counts

23 → 1

Calls

Call 1

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

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

Calls

5 calls:

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

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)

derivations127.0ms (2.3%)

Memory

-56.2MiB live, 161.3MiB allocated; 90ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 37 to 30 computations (18.9% saved)

preprocess35.0ms (0.6%)

Memory: 9.2MiB live, 100.9MiB allocated; 16ms 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%)

analyze223.0ms (4.1%)

sample1.5s (27.4%)

preprocess98.0ms (1.8%)

series110.0ms (2%)

rewrite207.0ms (3.8%)

eval476.0ms (8.7%)

prune14.0ms (0.3%)

series400.0ms (7.3%)

rewrite284.0ms (5.2%)

eval70.0ms (1.3%)

prune36.0ms (0.7%)

series365.0ms (6.7%)

rewrite262.0ms (4.8%)

eval64.0ms (1.2%)

prune56.0ms (1%)

series643.0ms (11.8%)

rewrite212.0ms (3.9%)

eval89.0ms (1.6%)

prune47.0ms (0.9%)

regimes101.0ms (1.9%)

regimes37.0ms (0.7%)

derivations127.0ms (2.3%)

preprocess35.0ms (0.6%)

end0.0ms (0%)

Profiling