math.log/2 on complex, real part

Time bar (total: 4.8s)

start0.0ms (0%)

Memory
0.2MiB live, 0.2MiB allocated; 0ms collecting garbage

analyze303.0ms (6.3%)

Memory
-0.2MiB live, 349.8MiB allocated; 191ms collecting garbage
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
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.4s (28.7%)

Memory
77.4MiB live, 1 650.0MiB allocated; 288ms collecting garbage
Samples
1.0s8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 652.0ms
ival-mult!: 187.0ms (28.7% of total)
ival-log: 178.0ms (27.3% of total)
ival-hypot: 152.0ms (23.3% of total)
ival-atan2: 62.0ms (9.5% of total)
ival-add!: 39.0ms (6% of total)
ival-div!: 31.0ms (4.8% of total)
adjust: 2.0ms (0.3% of total)
Bogosity

preprocess106.0ms (2.2%)

Memory
-28.9MiB live, 69.0MiB allocated; 31ms collecting garbage
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
079197
1337177
21747177
Stop Event
1×node-limit
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶56.0%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 44 to 36 computations (18.2% saved)

series103.0ms (2.1%)

Memory
43.7MiB live, 180.3MiB allocated; 14ms collecting garbage
Counts
18 → 112
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 (sqrt (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/2 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 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))))))
#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 (sqrt (pow im 2)) 2))) (* (log base) (log (sqrt (pow im 2)))))))
#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) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))))))))
#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) (+ (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow im 2)) 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 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 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 (sqrt (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/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 re 2))))))
#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 (sqrt (pow re 2)) 2))) (* (log base) (log (sqrt (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow re 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #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)))
Calls

9 calls:

TimeVariablePointExpression
50.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))
17.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))
15.0ms
base
@-inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
4.0ms
re
@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))
4.0ms
im
@0
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))

rewrite227.0ms (4.7%)

Memory
-18.0MiB live, 215.8MiB allocated; 79ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
05254499
05483934
137623716
087033001
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
130 → 434
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 (sqrt (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/2 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 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))))))
#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 (sqrt (pow im 2)) 2))) (* (log base) (log (sqrt (pow im 2)))))))
#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) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))))))))
#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) (+ (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow im 2)) 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 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 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 (sqrt (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/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 re 2))))))
#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 (sqrt (pow re 2)) 2))) (* (log base) (log (sqrt (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow re 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #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)))
Outputs
(*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(pow.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))) #s(literal -1 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 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (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 (fma.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)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64)))))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(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)))
(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))))
(*.f64 (sqrt.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64))) (fabs.f64 re))
(*.f64 (sqrt.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64))) (fabs.f64 im))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (fabs.f64 re))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (fabs.f64 im))
(*.f64 (fabs.f64 re) (sqrt.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64))))
(*.f64 (fabs.f64 re) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (fabs.f64 im) (sqrt.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64))))
(*.f64 (fabs.f64 im) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(sqrt.f64 (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (neg.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 (neg.f64 (neg.f64 re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (neg.f64 (neg.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (neg.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (neg.f64 im))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) im)
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (neg.f64 (neg.f64 re)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (neg.f64 (fabs.f64 re)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (fabs.f64 re))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 (neg.f64 (fabs.f64 re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) im)
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 (neg.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (fabs.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 re) (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 (fabs.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (neg.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im re)
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im))
(*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re))
(*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (neg.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (neg.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 (fabs.f64 re))) (exp.f64 (log.f64 (fabs.f64 re))) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 (fabs.f64 im))) (exp.f64 (log.f64 (fabs.f64 im))) (*.f64 re re))
(fma.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (neg.f64 (fabs.f64 re)) (neg.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 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(fma.f64 #s(literal 1 binary64) (*.f64 im im) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (*.f64 im im) #s(literal 1 binary64) (*.f64 (*.f64 im im) (/.f64 (*.f64 re 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 re re) (neg.f64 (*.f64 im im)))
(-.f64 (*.f64 im im) (neg.f64 (*.f64 re re)))
(+.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(+.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 re re)) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 im im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (exp.f64 (log.f64 (fabs.f64 re))) (exp.f64 (log.f64 (fabs.f64 re))))
(*.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 re re)
(pow.f64 (exp.f64 (log.f64 (fabs.f64 re))) #s(literal 2 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 re re)))
(sqrt.f64 (*.f64 (*.f64 re re) (*.f64 re re)))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 re re)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (fabs.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 (cosh.f64 (*.f64 (log.f64 (fabs.f64 re)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (fabs.f64 re)) #s(literal 2 binary64))))
re
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (exp.f64 (log.f64 (fabs.f64 im))) (exp.f64 (log.f64 (fabs.f64 im))))
(*.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(*.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 im im)
(pow.f64 (exp.f64 (log.f64 (fabs.f64 im))) #s(literal 2 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 im im)))
(sqrt.f64 (*.f64 (*.f64 im im) (*.f64 im im)))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (fabs.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) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (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 (log.f64 base) (log.f64 base))))
(/.f64 (neg.f64 (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 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 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (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))
(-.f64 (*.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 (pow.f64 base (log.f64 base)) (+.f64 #s(literal 1 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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (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 (log.f64 base) (log.f64 base))))
(/.f64 (neg.f64 (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 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 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (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))
(-.f64 (*.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 (pow.f64 base (log.f64 base)) (+.f64 #s(literal 1 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 (fabs.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 (fabs.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 (fabs.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 (fabs.f64 im)) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (log.f64 base) (*.f64 im im))) #s(literal 1/2 binary64) (*.f64 (log.f64 (fabs.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 (fabs.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 (log.f64 base) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64))) (*.f64 re re) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 im im))) (*.f64 re re) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (fabs.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 (fabs.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 (fabs.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 (fabs.f64 im))))
#s(approx (sqrt (+ (* re re) (* im im))) (fabs.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) (fabs.f64 im)) #s(literal 1/2 binary64) (fabs.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (fabs.f64 im) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (fabs.f64 im))) (fabs.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) (pow.f64 (fabs.f64 im) #s(literal -5 binary64))) #s(literal 1/16 binary64)) (/.f64 #s(literal 1/8 binary64) (*.f64 (fabs.f64 im) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (fabs.f64 im))) (*.f64 re re) (fabs.f64 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 (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 (+ (* re re) (* im im)) (fma.f64 im im (*.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 (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) (/.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 (/.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 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 base))))) (/.f64 (log.f64 (neg.f64 re)) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (log.f64 base) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal -1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (log.f64 base) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) #s(literal 120 binary64)) (log.f64 base)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.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) (log.f64 (neg.f64 re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.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 (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 (fabs.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 (fabs.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 (fabs.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 (*.f64 im im) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 base))) #s(literal 1/6 binary64)) (/.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 (fabs.f64 re)) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 re)) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 (fabs.f64 re)) (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 (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 (fabs.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 (fabs.f64 re)) (log.f64 base))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (fabs.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 (fabs.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 (fabs.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 (fabs.f64 re))))
#s(approx (sqrt (+ (* re re) (* im im))) (fabs.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 im im) (fabs.f64 re)) #s(literal 1/2 binary64) (fabs.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (fabs.f64 re) (*.f64 re re))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (fabs.f64 re))) (fabs.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (*.f64 (*.f64 (*.f64 im im) (pow.f64 (fabs.f64 re) #s(literal -5 binary64))) #s(literal 1/16 binary64)) (/.f64 #s(literal 1/8 binary64) (*.f64 (fabs.f64 re) (*.f64 re re)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (fabs.f64 re))) (*.f64 im im) (fabs.f64 re)))
#s(approx im im)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 base)))) (/.f64 (log.f64 im) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 base))))) (/.f64 (log.f64 im) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)) (*.f64 (*.f64 (*.f64 re re) (/.f64 (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 re re) (/.f64 (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 re re) (/.f64 (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)) (fma.f64 im im (*.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 (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) (/.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 (/.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 (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 re re) (/.f64 (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 re re) (/.f64 (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 re re) (/.f64 (log.f64 base) (*.f64 im im))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (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) (log.f64 (neg.f64 im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.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 (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)))

eval52.0ms (1.1%)

Memory
6.4MiB live, 93.2MiB allocated; 23ms collecting garbage
Compiler

Compiled 5 280 to 2 040 computations (61.4% saved)

prune21.0ms (0.4%)

Memory
0.0MiB live, 46.2MiB allocated; 4ms collecting garbage
Pruning

20 alts after pruning (20 fresh and 0 done)

PrunedKeptTotal
New35920379
Fresh000
Picked101
Done000
Total36020380
Accuracy
99.7%
Counts
380 → 20
Alt Table
Click to see full alt table
StatusAccuracyProgram
54.6%
(/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
54.5%
(/.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.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))))
▶99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
31.8%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64)))
56.0%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
▶5.5%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
23.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))))
31.8%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
32.1%
(/.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))))
5.7%
(/.f64 (log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
10.2%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 re)) (log.f64 base))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
98.3%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶56.0%
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))))
56.0%
(*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
▶56.2%
#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 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.2%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
▶98.6%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
Compiler

Compiled 944 to 798 computations (15.5% saved)

series262.0ms (5.5%)

Memory
-6.1MiB live, 377.8MiB allocated; 76ms collecting garbage
Counts
37 → 143
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(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))))
#s(literal 1 binary64)
(/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.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))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
(+.f64 (*.f64 (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)
(log.f64 (pow.f64 base (log.f64 base)))
(pow.f64 base (log.f64 base))
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 (sqrt (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/2 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 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))))))
#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 (sqrt (pow im 2)) 2))) (* (log base) (log (sqrt (pow im 2)))))))
#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) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))))))))
#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) (+ (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow im 2)) 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 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 (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow im 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (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 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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 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 (sqrt (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/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 re 2))))))
#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 (sqrt (pow re 2)) 2))) (* (log base) (log (sqrt (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow re 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log im) (log base)) #s(hole binary64 (/ (log im) (log base))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow re 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log base)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (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 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))))
#s(approx (pow base (log base)) #s(hole binary64 (exp (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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (sqrt (+ (pow im 2) (pow re 2))))))))
#s(approx (pow base (log base)) #s(hole binary64 (exp (pow (log (/ 1 base)) 2))))
Calls

9 calls:

TimeVariablePointExpression
71.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) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow 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 re) (* im im)) (* im im) (log (pow base (log base))) (pow base (log base)))
67.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) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow 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 re) (* im im)) (* im im) (log (pow base (log base))) (pow base (log base)))
35.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) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow 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 re) (* im im)) (* im im) (log (pow base (log base))) (pow base (log base)))
28.0ms
im
@0
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow 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 re) (* im im)) (* im im) (log (pow base (log base))) (pow base (log base)))
21.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) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (log (pow 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 re) (* im im)) (* im im) (log (pow base (log base))) (pow base (log base)))

rewrite352.0ms (7.3%)

Memory
-44.0MiB live, 249.9MiB allocated; 157ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
08256402
08765312
161835198
086715040
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
180 → 1 038
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(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))))
#s(literal 1 binary64)
(/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.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))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
(+.f64 (*.f64 (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)
(log.f64 (pow.f64 base (log.f64 base)))
(pow.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))) #s(hole binary64 (/ (log (sqrt (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/2 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 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))))))
#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 (sqrt (pow im 2)) 2))) (* (log base) (log (sqrt (pow im 2)))))))
#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) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))))))))
#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) (+ (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow im 2)) 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 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 (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow im 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (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 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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 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 (sqrt (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/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 re 2))))))
#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 (sqrt (pow re 2)) 2))) (* (log base) (log (sqrt (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow re 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log im) (log base)) #s(hole binary64 (/ (log im) (log base))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow re 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log base)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (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 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))))
#s(approx (pow base (log base)) #s(hole binary64 (exp (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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (sqrt (+ (pow im 2) (pow re 2))))))))
#s(approx (pow base (log base)) #s(hole binary64 (exp (pow (log (/ 1 base)) 2))))
Outputs
(*.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.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))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))))
(pow.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.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 -1 binary64) (neg.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(fma.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 #s(literal 1 binary64) (/.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))))
(exp.f64 (*.f64 (log.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))) #s(literal -1 binary64)))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.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)) (fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 #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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base))))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.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)) (fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 #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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base))))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(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))))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 re re)))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 im im)))
(*.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (fabs.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (fabs.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (neg.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) re)
(hypot.f64 im (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (sqrt.f64 (*.f64 re re)))
(hypot.f64 im re)
(hypot.f64 re (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (sqrt.f64 (*.f64 im im)))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
re
im
(log.f64 base)
base
#s(literal 0 binary64)
(atan2.f64 im re)
#s(literal 0 binary64)
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (log.f64 (pow.f64 base (/.f64 (log.f64 base) #s(literal 2 binary64)))) (log.f64 (pow.f64 base (/.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (+.f64 #s(literal 1 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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (log.f64 (pow.f64 base (/.f64 (log.f64 base) #s(literal 2 binary64)))) (log.f64 (pow.f64 base (/.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (+.f64 #s(literal 1 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 im) (log.f64 base)))
(*.f64 (/.f64 (log.f64 im) (neg.f64 (log.f64 base))) #s(literal -1 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 base)))
(/.f64 (log.f64 im) (log.f64 base))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im)))
(neg.f64 (/.f64 (log.f64 im) (neg.f64 (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)))) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (log.f64 base)))
(/.f64 #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))
(*.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))))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 re re)))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 im im)))
(*.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (fabs.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (fabs.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (neg.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) re)
(hypot.f64 im (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (sqrt.f64 (*.f64 re re)))
(hypot.f64 im re)
(hypot.f64 re (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (sqrt.f64 (*.f64 im im)))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im))
(*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re))
(*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (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 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)) (*.f64 im im))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(fma.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)) (*.f64 re re))
(fma.f64 (*.f64 im im) #s(literal 1 binary64) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(fma.f64 #s(literal 1 binary64) (*.f64 im im) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.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 re re) (neg.f64 (*.f64 im im)))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 re) re))
(-.f64 (*.f64 im im) (neg.f64 (*.f64 re re)))
(+.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(+.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 re re)) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 im im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(*.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(*.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(*.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))
(*.f64 re re)
(pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (*.f64 re re)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 2 binary64))))
(*.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.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))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))))
(pow.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.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 -1 binary64) (neg.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(fma.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 #s(literal 1 binary64) (/.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))))
(exp.f64 (*.f64 (log.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))) #s(literal -1 binary64)))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
#s(literal 1 binary64)
(*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base))) (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (/.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)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.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)) (fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 #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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base))))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)))
(*.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.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))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))))
(pow.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.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 -1 binary64) (neg.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(fma.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 #s(literal 1 binary64) (/.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))))
(exp.f64 (*.f64 (log.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))) #s(literal -1 binary64)))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.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)) (fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 #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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base))))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.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)) (fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 #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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base))))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(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))))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 re re)))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 im im)))
(*.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (fabs.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (fabs.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (neg.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) re)
(hypot.f64 im (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (sqrt.f64 (*.f64 re re)))
(hypot.f64 im re)
(hypot.f64 re (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (sqrt.f64 (*.f64 im im)))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im))
(*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re))
(*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (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 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)) (*.f64 im im))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(fma.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)) (*.f64 re re))
(fma.f64 (*.f64 im im) #s(literal 1 binary64) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(fma.f64 #s(literal 1 binary64) (*.f64 im im) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.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 re re) (neg.f64 (*.f64 im im)))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 re) re))
(-.f64 (*.f64 im im) (neg.f64 (*.f64 re re)))
(+.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(+.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 re re)) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 im im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(*.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(*.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))
(*.f64 im im)
(pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im 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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (log.f64 (pow.f64 base (/.f64 (log.f64 base) #s(literal 2 binary64)))) (log.f64 (pow.f64 base (/.f64 (log.f64 base) #s(literal 2 binary64)))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (+.f64 #s(literal 1 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 (pow.f64 base (/.f64 (log.f64 base) #s(literal 2 binary64))) (pow.f64 base (/.f64 (log.f64 base) #s(literal 2 binary64))))
(pow.f64 base (log.f64 base))
(fabs.f64 (pow.f64 base (log.f64 base)))
(exp.f64 (*.f64 (log.f64 base) (log.f64 base)))
(+.f64 (cosh.f64 (*.f64 (log.f64 base) (log.f64 base))) (sinh.f64 (*.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 (*.f64 im im))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base))) #s(literal 1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (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 (sqrt.f64 (*.f64 im im))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.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 (sqrt.f64 (*.f64 im im))) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (log.f64 base) (*.f64 im im))) #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im 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 (sqrt.f64 (*.f64 im im))) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 base) (*.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (*.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64))) (*.f64 re re) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 im im))) (*.f64 re re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 im 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 (sqrt.f64 (*.f64 im 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 (sqrt.f64 (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) (sqrt.f64 (*.f64 im im))) #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (sqrt.f64 (*.f64 im im)) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))) (*.f64 re re) (sqrt.f64 (*.f64 im 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 (*.f64 im im) #s(literal 5/2 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))) (*.f64 re re) (sqrt.f64 (*.f64 im 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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (-.f64 (neg.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)))))) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im)))) (*.f64 re re) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (fma.f64 (-.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 im im))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 im #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 base)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (*.f64 re re))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64))))))) (*.f64 re re) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im))))) (*.f64 re re) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.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 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 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)))) (neg.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 base))))) (neg.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 base)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (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) (neg.f64 (neg.f64 (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))) (neg.f64 (neg.f64 (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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) (neg.f64 (neg.f64 (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 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* im im) (* re re)) (fma.f64 im im (*.f64 re re)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal -1/4 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 re re))) #s(literal 1/2 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal -1/4 binary64))) (*.f64 im im)) (neg.f64 (log.f64 re))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal 1/720 binary64)))) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 re re))) #s(literal 1/2 binary64))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 base))) #s(literal 1/2 binary64) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 base))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 base)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 re) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (*.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 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal -1/4 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re re))) #s(literal 1/2 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal -1/4 binary64))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal 1/720 binary64)))) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re re))) #s(literal 1/2 binary64))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 base))) #s(literal 1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (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 (sqrt.f64 (*.f64 re re))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.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 (sqrt.f64 (*.f64 re re))) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (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 (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 (sqrt.f64 (*.f64 re re))) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 base) (*.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (log.f64 base)) (*.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))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 re 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 (sqrt.f64 (*.f64 re 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 (sqrt.f64 (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 re re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 im im) (sqrt.f64 (*.f64 re re))) #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (sqrt.f64 (*.f64 re re)) (*.f64 re re))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re)))) (*.f64 im im) (sqrt.f64 (*.f64 re 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 (*.f64 re re) #s(literal 5/2 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (sqrt.f64 (*.f64 re re)) (*.f64 re re)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re)))) (*.f64 im im) (sqrt.f64 (*.f64 re re))))
#s(approx im im)
#s(approx (/ (log im) (log base)) (/.f64 (log.f64 im) (log.f64 base)))
#s(approx (log im) (log.f64 im))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (-.f64 (neg.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re)))) (*.f64 im im) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (fma.f64 (-.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 re #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 base)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (*.f64 im im))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))) (*.f64 im im) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re))))) (*.f64 im im) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (neg.f64 (neg.f64 (log.f64 im))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (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 (neg.f64 (neg.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 (neg.f64 (neg.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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 base))))) (/.f64 (neg.f64 (neg.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 re re) (/.f64 (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 re re) (/.f64 (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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (*.f64 (*.f64 re re) (/.f64 (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 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 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))) (neg.f64 (neg.f64 (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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) (neg.f64 (neg.f64 (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 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (+ (* im im) (* re re)) (fma.f64 im im (*.f64 re re)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (log.f64 base) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 im im)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal -1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)))) (*.f64 (*.f64 (*.f64 re re) (/.f64 (log.f64 base) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 im im)))) #s(literal 1/2 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal -1/4 binary64))) (*.f64 re re)) (neg.f64 (log.f64 im))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal 1/720 binary64)))) (pow.f64 im #s(literal 6 binary64)))) (/.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 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 (*.f64 im im) (*.f64 im im))))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 (log.f64 base) (*.f64 (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))) #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (/.f64 (log.f64 base) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 im im)))) #s(literal 1/2 binary64))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base))) #s(literal 1/2 binary64) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 base))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 base))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 base)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (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 re re) (/.f64 (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 re re) (/.f64 (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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (*.f64 (*.f64 re re) (/.f64 (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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 im) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (*.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 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) #s(literal 1 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal -1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im im))) #s(literal 1/2 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal -1/4 binary64))) (neg.f64 (log.f64 (neg.f64 im))))) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal 1/720 binary64)))) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im im))) #s(literal 1/2 binary64))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(approx (log base) (log.f64 base))
#s(approx base base)
#s(approx (+ (* (log base) (log base)) (* 0 0)) (*.f64 (log.f64 base) (log.f64 base)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(approx (pow base (log base)) (pow.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 im) (log base)) (/.f64 (log.f64 im) (log.f64 base)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (neg.f64 (log.f64 base))) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(approx (pow base (log base)) (pow.f64 base (log.f64 base)))

eval82.0ms (1.7%)

Memory
11.8MiB live, 148.7MiB allocated; 34ms collecting garbage
Compiler

Compiled 8 060 to 2 796 computations (65.3% saved)

prune35.0ms (0.7%)

Memory
-12.7MiB live, 88.8MiB allocated; 13ms collecting garbage
Pruning

29 alts after pruning (27 fresh and 2 done)

PrunedKeptTotal
New54416560
Fresh41115
Picked325
Done000
Total55129580
Accuracy
99.9%
Counts
580 → 29
Alt Table
Click to see full alt table
StatusAccuracyProgram
54.6%
(/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
54.5%
(/.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.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))))
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 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
99.0%
(/.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 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
46.0%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
▶51.3%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
▶99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
56.0%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
23.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))))
31.8%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
10.2%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 re)) (log.f64 base))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
98.3%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶56.0%
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
55.9%
(/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
55.9%
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
0.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))))
▶0.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))))
10.2%
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))))
56.0%
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
27.9%
(exp.f64 (*.f64 (log.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))) #s(literal -1 binary64)))
✓56.2%
#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 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.2%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
✓98.6%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
98.5%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))))
56.1%
#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)))) (/.f64 #s(literal 1 binary64) (log.f64 base))))
98.5%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 base))))
Compiler

Compiled 1 303 to 1 113 computations (14.6% saved)

series422.0ms (8.8%)

Memory
43.1MiB live, 561.0MiB allocated; 119ms collecting garbage
Counts
40 → 155
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(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))))
#s(literal 1 binary64)
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im)))))
(/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))
(neg.f64 (log.f64 base))
(neg.f64 (log.f64 (neg.f64 im)))
(log.f64 (neg.f64 im))
(neg.f64 im)
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(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 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
(atan2.f64 im re)
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))
(log.f64 (log.f64 base))
#s(literal 2 binary64)
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 (sqrt (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/2 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 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))))))
#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 (sqrt (pow im 2)) 2))) (* (log base) (log (sqrt (pow im 2)))))))
#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) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))))))))
#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) (+ (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow im 2)) 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (atan2 im re) 0) #s(hole binary64 0))
#s(approx (/ (log re) (log base)) #s(hole binary64 (/ (log re) (log base))))
#s(approx (log re) #s(hole binary64 (log re)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow im 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 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 (sqrt (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/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 re 2))))))
#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 (sqrt (pow re 2)) 2))) (* (log base) (log (sqrt (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow re 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow re 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log base)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (neg (log base)) (neg (log (neg im)))) #s(hole binary64 (/ (log base) (log (neg im)))))
#s(approx (neg (log (neg im))) #s(hole binary64 (* -1 (log (neg im)))))
#s(approx (log (neg im)) #s(hole binary64 (log (neg im))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))))
#s(approx (/ (neg (log base)) (neg (log (neg im)))) #s(hole binary64 (* -1 (/ (log base) (log (neg (/ 1 im)))))))
#s(approx (neg (log (neg im))) #s(hole binary64 (log (neg (/ 1 im)))))
#s(approx (log (neg im)) #s(hole binary64 (* -1 (log (neg (/ 1 im))))))
#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)) (+ (* (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 (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))))
#s(approx (neg (log (neg 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)) (* 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (log base))))
#s(approx (* (log (log base)) 2) #s(hole binary64 (* 2 (log (log base)))))
#s(approx (log (log base)) #s(hole binary64 (log (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (sqrt (+ (pow im 2) (pow re 2))))))))
#s(approx (/ (neg (log base)) (neg (log (neg im)))) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (neg im))))))
#s(approx (neg (log base)) #s(hole binary64 (log (/ 1 base))))
#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))))))
Calls

9 calls:

TimeVariablePointExpression
123.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) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (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)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2)
72.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) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (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)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2)
51.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) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (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)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2)
46.0ms
im
@0
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (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)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2)
39.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) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (neg (log base)) (neg (log (neg im)))) (neg (log base)) (neg (log (neg im))) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (* (log base) (log base)) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (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)) (exp (* (log (log base)) 2))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (exp (* (log (log base)) 2)) (* (log (log base)) 2) (log (log base)) 2)

rewrite289.0ms (6%)

Memory
27.6MiB live, 430.1MiB allocated; 92ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
08556590
09085443
163095329
088595170
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
195 → 890
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(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))))
#s(literal 1 binary64)
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im)))))
(/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))
(neg.f64 (log.f64 base))
(neg.f64 (log.f64 (neg.f64 im)))
(log.f64 (neg.f64 im))
(neg.f64 im)
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(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 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
(atan2.f64 im re)
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))
(log.f64 (log.f64 base))
#s(literal 2 binary64)
#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))) (log base))))
#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) (* (log base) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 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))))))
#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 (sqrt (pow im 2)) 2))) (* (log base) (log (sqrt (pow im 2)))))))
#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) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))))))))
#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) (+ (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow im 2)) 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (atan2 im re) 0) #s(hole binary64 0))
#s(approx (/ (log re) (log base)) #s(hole binary64 (/ (log re) (log base))))
#s(approx (log re) #s(hole binary64 (log re)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow im 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 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 (sqrt (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/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 re 2))))))
#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 (sqrt (pow re 2)) 2))) (* (log base) (log (sqrt (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow re 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow re 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log base)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (neg (log base)) (neg (log (neg im)))) #s(hole binary64 (/ (log base) (log (neg im)))))
#s(approx (neg (log (neg im))) #s(hole binary64 (* -1 (log (neg im)))))
#s(approx (log (neg im)) #s(hole binary64 (log (neg im))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))))
#s(approx (/ (neg (log base)) (neg (log (neg im)))) #s(hole binary64 (* -1 (/ (log base) (log (neg (/ 1 im)))))))
#s(approx (neg (log (neg im))) #s(hole binary64 (log (neg (/ 1 im)))))
#s(approx (log (neg im)) #s(hole binary64 (* -1 (log (neg (/ 1 im))))))
#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)) (+ (* (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 (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))))
#s(approx (neg (log (neg 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)) (* 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (log base))))
#s(approx (* (log (log base)) 2) #s(hole binary64 (* 2 (log (log base)))))
#s(approx (log (log base)) #s(hole binary64 (log (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (sqrt (+ (pow im 2) (pow re 2))))))))
#s(approx (/ (neg (log base)) (neg (log (neg im)))) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (neg im))))))
#s(approx (neg (log base)) #s(hole binary64 (log (/ 1 base))))
#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))))))
Outputs
(*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (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 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (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 (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)))
(fma.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)) (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 #s(literal 1 binary64) (/.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))))
(fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (*.f64 #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)) (pow.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 (*.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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 #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)))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 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 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.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)) (fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 #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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(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)))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(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))))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 re re)))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 im im)))
(*.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) re)
(hypot.f64 (fabs.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (fabs.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (neg.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) re)
(hypot.f64 (neg.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 im (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (sqrt.f64 (*.f64 re re)))
(hypot.f64 im re)
(hypot.f64 re (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (sqrt.f64 (*.f64 im 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
(log.f64 base)
base
#s(approx (* (atan2 im re) 0) #s(literal 0 binary64))
#s(literal 0 binary64)
(*.f64 (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 1 binary64)) (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 1 binary64)))
(*.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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(pow.f64 (neg.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 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 1 binary64)) (pow.f64 (exp.f64 (log.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)) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64) #s(literal 0 binary64))
(-.f64 (*.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 (exp.f64 (log.f64 (log.f64 base)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (+.f64 #s(literal 1 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 (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 1 binary64)) (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 1 binary64)))
(*.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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(pow.f64 (neg.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 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 1 binary64)) (pow.f64 (exp.f64 (log.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)) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64) #s(literal 0 binary64))
(-.f64 (*.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 (exp.f64 (log.f64 (log.f64 base)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (+.f64 #s(literal 1 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 (log.f64 re) (neg.f64 (log.f64 base))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 re) (neg.f64 (log.f64 base))))
(*.f64 (log.f64 re) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 base)))
(/.f64 (log.f64 re) (log.f64 base))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 re)))
(neg.f64 (/.f64 (log.f64 re) (neg.f64 (log.f64 base))))
(log.f64 re)
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))))
(pow.f64 #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))))
(exp.f64 (*.f64 (log.f64 #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))) #s(literal -1 binary64)))
#s(literal 1 binary64)
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
(*.f64 (/.f64 (neg.f64 (log.f64 base)) (log.f64 (neg.f64 im))) #s(literal -1 binary64))
(*.f64 (neg.f64 (log.f64 base)) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (neg.f64 im)))))
(*.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 (neg.f64 im)))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 base)) (log.f64 (neg.f64 im))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (neg.f64 (log.f64 (neg.f64 im)))))
(*.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 (neg.f64 im))))
(/.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
(/.f64 (neg.f64 (neg.f64 (log.f64 base))) (log.f64 (neg.f64 im)))
(/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 base))))
(/.f64 (log.f64 base) (log.f64 (neg.f64 im)))
(neg.f64 (/.f64 (neg.f64 (log.f64 base)) (log.f64 (neg.f64 im))))
(neg.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 (neg.f64 im)))))
(*.f64 #s(literal -1 binary64) (log.f64 base))
(*.f64 (log.f64 base) #s(literal -1 binary64))
(neg.f64 (log.f64 (/.f64 base #s(literal 1 binary64))))
(neg.f64 (log.f64 base))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 base)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 base #s(literal 1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 base))
(+.f64 #s(literal 0 binary64) (neg.f64 (log.f64 base)))
(log.f64 (/.f64 #s(literal 1 binary64) base))
(*.f64 (log.f64 (neg.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 (neg.f64 im)))
(neg.f64 (log.f64 (/.f64 im #s(literal -1 binary64))))
(neg.f64 (log.f64 (neg.f64 im)))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 im #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 (neg.f64 im)))
(+.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(log.f64 (/.f64 #s(literal -1 binary64) im))
(+.f64 (log.f64 im) (log.f64 #s(literal -1 binary64)))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))
(log.f64 (neg.f64 im))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(neg.f64 im)
(*.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 #s(literal 1 binary64) (/.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 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(pow.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.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))))) (*.f64 (log.f64 base) (log.f64 base)))
(fma.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 #s(literal 1 binary64) (/.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))))
(fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64)))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
(*.f64 (/.f64 (log.f64 base) (log.f64 base)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (log.f64 base)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base))) (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (/.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)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.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)) (fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 #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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(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)))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(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))))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 re re)))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 im im)))
(*.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) re)
(hypot.f64 (fabs.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (fabs.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (neg.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) re)
(hypot.f64 (neg.f64 im) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 im (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (sqrt.f64 (*.f64 re re)))
(hypot.f64 im re)
(hypot.f64 re (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (sqrt.f64 (*.f64 im im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im))
(*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re))
(*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 1 binary64)) (*.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 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)) (*.f64 im im))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(fma.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)) (*.f64 re re))
(fma.f64 (*.f64 im im) #s(literal 1 binary64) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(fma.f64 #s(literal 1 binary64) (*.f64 im im) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.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 re re) (neg.f64 (*.f64 im im)))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 re) re))
(-.f64 (*.f64 im im) (neg.f64 (*.f64 re re)))
(+.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(+.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 re re)) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 im im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(*.f64 (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 re #s(literal 1 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(*.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(*.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 1 binary64)))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))
(*.f64 re re)
(pow.f64 (sqrt.f64 (*.f64 re re)) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (*.f64 re re)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re 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 (pow.f64 (/.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 #s(literal 1 binary64) (/.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 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(pow.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64))
(/.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.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))))) (*.f64 (log.f64 base) (log.f64 base)))
(fma.f64 (pow.f64 (/.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 #s(literal 1 binary64) (/.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))))
(fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64)))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.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)) (fma.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 #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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(+.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(log.f64 (pow.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(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)))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)))
#s(literal 0 binary64)
(atan2.f64 im re)
(*.f64 (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 1 binary64)) (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 1 binary64)))
(*.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 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(pow.f64 (neg.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 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 1 binary64)) (pow.f64 (exp.f64 (log.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)) (pow.f64 (neg.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64) #s(literal 0 binary64))
(-.f64 (*.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 (exp.f64 (log.f64 (log.f64 base)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (+.f64 #s(literal 1 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 (log.f64 (neg.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))
(*.f64 #s(literal 2 binary64) (log.f64 (exp.f64 (log.f64 (log.f64 base)))))
(*.f64 #s(literal 2 binary64) (log.f64 (neg.f64 (log.f64 base))))
(*.f64 #s(literal 2 binary64) (log.f64 (neg.f64 (neg.f64 (log.f64 base)))))
(*.f64 #s(literal 2 binary64) (log.f64 (log.f64 base)))
(-.f64 (log.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64))) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(-.f64 (log.f64 (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))) (log.f64 (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
(+.f64 (log.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (log.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64))) (log.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64))))
(+.f64 (log.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64))) (log.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64))))
(+.f64 (log.f64 (fabs.f64 (log.f64 base))) (log.f64 (fabs.f64 (log.f64 base))))
(+.f64 (log.f64 (exp.f64 (log.f64 (log.f64 base)))) (log.f64 (exp.f64 (log.f64 (log.f64 base)))))
(+.f64 (log.f64 (neg.f64 (log.f64 base))) (log.f64 (neg.f64 (log.f64 base))))
(+.f64 (log.f64 (neg.f64 (neg.f64 (log.f64 base)))) (log.f64 (neg.f64 (neg.f64 (log.f64 base)))))
(+.f64 (log.f64 (log.f64 base)) (log.f64 (log.f64 base)))
(log.f64 (*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base)))))
(log.f64 (*.f64 (log.f64 base) (log.f64 base)))
(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 (sqrt.f64 (*.f64 im im))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base))) #s(literal 1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (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 (sqrt.f64 (*.f64 im im))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.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 (sqrt.f64 (*.f64 im im))) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (log.f64 base) (*.f64 im im))) #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im 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 (sqrt.f64 (*.f64 im im))) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 base) (*.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (*.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64))) (*.f64 re re) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 im im))) (*.f64 re re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 im 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 (sqrt.f64 (*.f64 im 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 (sqrt.f64 (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) (sqrt.f64 (*.f64 im im))) #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (sqrt.f64 (*.f64 im im)) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))) (*.f64 re re) (sqrt.f64 (*.f64 im 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 (*.f64 im im) #s(literal 5/2 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))) (*.f64 re re) (sqrt.f64 (*.f64 im im))))
#s(approx re re)
#s(approx (* (atan2 im re) 0) #s(literal 0 binary64))
#s(approx (/ (log re) (log base)) (/.f64 (log.f64 re) (log.f64 base)))
#s(approx (log re) (log.f64 re))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (-.f64 (neg.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)))))) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im)))) (*.f64 re re) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (fma.f64 (-.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 im im))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 base) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 base)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)))))) (*.f64 re re))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 base) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64))))))) (*.f64 re re) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im))))) (*.f64 re re) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (+ (* im im) (* re re)) (*.f64 im im))
#s(approx (+ (* im im) (* re re)) (fma.f64 im im (*.f64 re re)))
#s(approx (* re re) (*.f64 re re))
#s(approx (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 (neg.f64 (neg.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 (neg.f64 (neg.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 (neg.f64 (neg.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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 base))))) (/.f64 (neg.f64 (neg.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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (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) (neg.f64 (neg.f64 (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))) (neg.f64 (neg.f64 (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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) (neg.f64 (neg.f64 (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 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (*.f64 (*.f64 im im) (/.f64 (log.f64 base) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 re re)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal -1/4 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))) (*.f64 (*.f64 (*.f64 im im) (/.f64 (log.f64 base) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 re re)))) #s(literal 1/2 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal -1/4 binary64))) (*.f64 im im)) (neg.f64 (log.f64 re))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal 1/720 binary64)))) (pow.f64 re #s(literal 6 binary64)))) (/.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 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re))))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (log.f64 base) (*.f64 (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))) #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (/.f64 (log.f64 base) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 re re)))) #s(literal 1/2 binary64))))))
#s(approx (+ (* im im) (* re re)) (fma.f64 im im (*.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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 base)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 re) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (*.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 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal -1/4 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re re))) #s(literal 1/2 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal -1/4 binary64))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal 1/720 binary64)))) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re re))) #s(literal 1/2 binary64))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 base))) #s(literal 1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (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 (sqrt.f64 (*.f64 re re))) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.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 (sqrt.f64 (*.f64 re re))) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (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 (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 (sqrt.f64 (*.f64 re re))) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 base) (*.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (log.f64 base)) (*.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))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 re 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 (sqrt.f64 (*.f64 re 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 (sqrt.f64 (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 re re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 im im) (sqrt.f64 (*.f64 re re))) #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (sqrt.f64 (*.f64 re re)) (*.f64 re re))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re)))) (*.f64 im im) (sqrt.f64 (*.f64 re 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 (*.f64 re re) #s(literal 5/2 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (sqrt.f64 (*.f64 re re)) (*.f64 re re)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re)))) (*.f64 im im) (sqrt.f64 (*.f64 re re))))
#s(approx im im)
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (-.f64 (neg.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 base)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re)))) (*.f64 im im) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (fma.f64 (-.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 re #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 base)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (*.f64 im im))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))) (*.f64 im im) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re))))) (*.f64 im im) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (neg (log base)) (neg (log (neg im)))) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (log.f64 (neg.f64 im)))
#s(approx (neg im) (neg.f64 im))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (neg.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) (neg.f64 (/.f64 (neg.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)))) (neg.f64 (/.f64 (neg.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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 base))))) (neg.f64 (/.f64 (neg.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 re re) (/.f64 (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 re re) (/.f64 (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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (*.f64 (*.f64 re re) (/.f64 (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 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 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))) (neg.f64 (neg.f64 (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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) (neg.f64 (neg.f64 (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 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal -1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)))) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 im im))) #s(literal 1/2 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal -1/4 binary64))) (*.f64 re re)) (neg.f64 (log.f64 im))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal 1/720 binary64)))) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 im im))) #s(literal 1/2 binary64))))))
#s(approx (/ (neg (log base)) (neg (log (neg im)))) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (+ (* im im) (* re re)) (fma.f64 im im (*.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 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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 base)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (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 re re) (/.f64 (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 re re) (/.f64 (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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (*.f64 (*.f64 re re) (/.f64 (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 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (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 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) #s(literal 1 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal -1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im im))) #s(literal 1/2 binary64))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal -1/4 binary64))) (neg.f64 (log.f64 (neg.f64 im))))) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal 1/720 binary64)))) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im im))) #s(literal 1/2 binary64))))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 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 base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(approx (neg (log base)) (neg.f64 (log.f64 base)))
#s(approx (* (log (log base)) 2) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
#s(approx (log (log base)) (log.f64 (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 re) (log base)) (/.f64 (log.f64 re) (log.f64 base)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (neg.f64 (log.f64 base))) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(approx (/ (neg (log base)) (neg (log (neg im)))) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
#s(approx (neg (log base)) (neg.f64 (log.f64 base)))
#s(approx (* (log (log base)) 2) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
#s(approx (log (log base)) (log.f64 (neg.f64 (neg.f64 (log.f64 base)))))

eval113.0ms (2.4%)

Memory
-23.2MiB live, 213.8MiB allocated; 44ms collecting garbage
Compiler

Compiled 10 584 to 3 220 computations (69.6% saved)

prune57.0ms (1.2%)

Memory
-16.9MiB live, 93.6MiB allocated; 49ms collecting garbage
Pruning

28 alts after pruning (24 fresh and 4 done)

PrunedKeptTotal
New7759784
Fresh71522
Picked325
Done022
Total78528813
Accuracy
99.9%
Counts
813 → 28
Alt Table
Click to see full alt table
StatusAccuracyProgram
54.6%
(/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
54.5%
(/.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.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))))
99.0%
(/.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 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
99.1%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
▶99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
46.0%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
51.3%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
56.0%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
10.2%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 re)) (log.f64 base))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
98.3%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
✓56.0%
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
55.9%
(/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
▶55.9%
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
0.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))))
▶0.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))))
0.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (*.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 (neg.f64 im))))))
27.9%
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64)))
✓56.2%
#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 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.2%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
✓98.6%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
10.2%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 re))))
98.5%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))))
56.1%
#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)))) (/.f64 #s(literal 1 binary64) (log.f64 base))))
10.2%
#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) (log.f64 base))))
98.5%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 base))))
Compiler

Compiled 1 254 to 1 072 computations (14.5% saved)

series342.0ms (7.1%)

Memory
65.4MiB live, 559.5MiB allocated; 104ms collecting garbage
Counts
40 → 219
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))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
(/.f64 (log.f64 (neg.f64 im)) (log.f64 base))
(log.f64 (neg.f64 im))
(neg.f64 im)
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))))
#s(literal 1 binary64)
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
(/.f64 (log.f64 base) (log.f64 (neg.f64 im)))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(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 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.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 (exp.f64 (log.f64 (fabs.f64 re))) im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) im)) (log.f64 base))
(log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) im))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) im)
(exp.f64 (log.f64 (fabs.f64 re)))
(log.f64 (fabs.f64 re))
(fabs.f64 re)
(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
(atan2.f64 im re)
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
Outputs
#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))) (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) (* (log base) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 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))))))
#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 (sqrt (pow im 2)) 2))) (* (log base) (log (sqrt (pow im 2)))))))
#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) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))))))))
#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) (+ (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow im 2)) 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (atan2 im re) 0) #s(hole binary64 0))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow im 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ 1 (log (sqrt (pow im 2))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ 1 (log (sqrt (pow im 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ 1 (log (sqrt (pow im 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 1/8 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (+ (* 1/6 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))) (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ 1 (log (sqrt (pow im 2)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log (sqrt (+ (pow im 2) (pow (fabs re) 2)))) (log base))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log (sqrt (+ (pow im 2) (pow (fabs re) 2)))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (log (sqrt (+ (pow im 2) (pow (fabs re) 2))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (sqrt (+ (pow im 2) (pow (fabs re) 2)))))
#s(approx (exp (log (fabs re))) #s(hole binary64 (fabs re)))
#s(approx (log (fabs re)) #s(hole binary64 (log (fabs re))))
#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))) #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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ -1 (log (/ 1 re)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (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)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ -1 (log (/ -1 re)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 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 (sqrt (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/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 re 2))))))
#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 (sqrt (pow re 2)) 2))) (* (log base) (log (sqrt (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow re 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log (neg im)) (log base)) #s(hole binary64 (/ (log (neg im)) (log base))))
#s(approx (log (neg im)) #s(hole binary64 (log (neg im))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow re 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log base)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (log base) (log (neg im))) #s(hole binary64 (/ (log base) (log (neg im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ 1 (log (sqrt (pow re 2))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ 1 (log (sqrt (pow re 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ 1 (log (sqrt (pow re 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 1/8 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (+ (* 1/6 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))) (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ 1 (log (sqrt (pow re 2)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log (sqrt (pow (fabs re) 2))) (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow (fabs re) 2)) 2)))) (/ (log (sqrt (pow (fabs re) 2))) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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) (* (log base) (pow (sqrt (pow (fabs re) 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow (fabs re) 2)) 2)))))) (/ (log (sqrt (pow (fabs re) 2))) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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) (* (log base) (pow (sqrt (pow (fabs re) 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow (fabs re) 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow (fabs re) 2)) 2)))))) (/ (log (sqrt (pow (fabs re) 2))) (log base)))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log (sqrt (pow (fabs re) 2))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* 1/2 (/ (* (pow im 2) (log base)) (pow (sqrt (pow (fabs re) 2)) 2))) (* (log base) (log (sqrt (pow (fabs re) 2)))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow (fabs re) 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow (fabs re) 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow (fabs re) 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow (fabs re) 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow (fabs re) 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow (fabs re) 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow (fabs re) 2)) 6))))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (log (sqrt (pow (fabs re) 2)))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow (fabs re) 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 2))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow (fabs re) 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow (fabs re) 2)) 2))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow (fabs re) 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow (fabs re) 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow (fabs re) 2)) 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (sqrt (pow (fabs re) 2))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (+ (sqrt (pow (fabs re) 2)) (* 1/2 (/ (pow im 2) (sqrt (pow (fabs re) 2)))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (+ (sqrt (pow (fabs re) 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 3))) (* 1/2 (/ 1 (sqrt (pow (fabs re) 2)))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (+ (sqrt (pow (fabs re) 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow (fabs re) 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow (fabs re) 2)))))))))
#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 (/ (log (neg im)) (log base)) #s(hole binary64 (* -1 (/ (log (neg (/ 1 im))) (log base)))))
#s(approx (log (neg im)) #s(hole binary64 (* -1 (log (neg (/ 1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))))
#s(approx (/ (log base) (log (neg im))) #s(hole binary64 (* -1 (/ (log base) (log (neg (/ 1 im)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ -1 (log (/ 1 im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow (fabs re) 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow (fabs re) 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow (fabs re) 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow (fabs re) 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6)))) (pow im 6))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow (fabs re) 4) (pow im 4))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow (fabs re) 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6))) (pow im 6))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow (fabs re) 4) (pow im 4))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow (fabs re) 4) (pow im 4))) (+ (* 1/16 (/ (pow (fabs re) 6) (pow im 6))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))))
#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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ -1 (log (/ -1 im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow (fabs re) 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow (fabs re) 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow (fabs re) 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow (fabs re) 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6)))) (pow im 6))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow (fabs re) 4) (pow im 4))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow (fabs re) 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6))) (pow im 6))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow (fabs re) 4) (pow im 4))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow (fabs re) 4) (pow im 4))) (+ (* 1/16 (/ (pow (fabs re) 6) (pow im 6))) (* 1/2 (/ (pow (fabs re) 2) (pow im 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 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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ 1 (log (sqrt (+ (pow im 2) (pow re 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 (/ (log (neg im)) (log base)) #s(hole binary64 (* -1 (/ (log (neg im)) (log (/ 1 base))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (sqrt (+ (pow im 2) (pow re 2))))))))
#s(approx (/ (log base) (log (neg im))) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (neg im))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 2)))) (log (/ 1 base))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log (sqrt (+ (pow im 2) (pow (fabs re) 2)))) (log (/ 1 base))))))
Calls

9 calls:

TimeVariablePointExpression
65.0ms
re
@inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (neg im)) (log base)) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (log base) (log (neg im))) (/ 1 (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))))) (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) (exp (log (fabs re))) (log (fabs re)) (fabs re) (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0))
49.0ms
re
@0
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (neg im)) (log base)) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (log base) (log (neg im))) (/ 1 (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))))) (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) (exp (log (fabs re))) (log (fabs re)) (fabs re) (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0))
44.0ms
re
@-inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log base) base (* (atan2 im re) 0) 0 (* (log base) (log base)) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (neg im)) (log base)) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (log base) (log (neg im))) (/ 1 (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))))) (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) (exp (log (fabs re))) (log (fabs re)) (fabs re) (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0))
40.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))) (/ (log (neg im)) (log base)) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (log base) (log (neg im))) (/ 1 (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))))) (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) (exp (log (fabs re))) (log (fabs re)) (fabs re) (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0))
37.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))) (/ (log (neg im)) (log base)) (log (neg im)) (neg im) (/ 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))) 1 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/ (log base) (log (neg im))) (/ 1 (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))))) (* (log base) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re))))))) (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (* (log base) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) (exp (log (fabs re))) (log (fabs re)) (fabs re) (* (atan2 im re) 0) (atan2 im re) (+ (* (log base) (log base)) (* 0 0)) (* 0 0))

rewrite220.0ms (4.6%)

Memory
-19.1MiB live, 217.2MiB allocated; 77ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0128210372
013459221
087798565
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
259 → 426
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))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
(/.f64 (log.f64 (neg.f64 im)) (log.f64 base))
(log.f64 (neg.f64 im))
(neg.f64 im)
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))))
#s(literal 1 binary64)
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
(/.f64 (log.f64 base) (log.f64 (neg.f64 im)))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(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 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.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 (exp.f64 (log.f64 (fabs.f64 re))) im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) im)) (log.f64 base))
(log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) im))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) im)
(exp.f64 (log.f64 (fabs.f64 re)))
(log.f64 (fabs.f64 re))
(fabs.f64 re)
(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
(atan2.f64 im re)
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 #s(literal 0 binary64) #s(literal 0 binary64))
#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))) (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) (* (log base) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log base) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 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))))))
#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 (sqrt (pow im 2)) 2))) (* (log base) (log (sqrt (pow im 2)))))))
#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) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))))))))
#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) (+ (* 1/2 (/ (log base) (pow (sqrt (pow im 2)) 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow im 2)) 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow (sqrt (pow im 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow im 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow im 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow im 2)) 3))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow im 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow im 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow im 2)))))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (atan2 im re) 0) #s(hole binary64 0))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow im 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log base)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log base) (log (sqrt (pow im 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ 1 (log (sqrt (pow im 2))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ 1 (log (sqrt (pow im 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ 1 (log (sqrt (pow im 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 1/8 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (+ (* 1/6 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))) (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ 1 (log (sqrt (pow im 2)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log (sqrt (+ (pow im 2) (pow (fabs re) 2)))) (log base))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log (sqrt (+ (pow im 2) (pow (fabs re) 2)))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (log (sqrt (+ (pow im 2) (pow (fabs re) 2))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (sqrt (+ (pow im 2) (pow (fabs re) 2)))))
#s(approx (exp (log (fabs re))) #s(hole binary64 (fabs re)))
#s(approx (log (fabs re)) #s(hole binary64 (log (fabs re))))
#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))) #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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ -1 (log (/ 1 re)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (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)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 re))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log base)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log base)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log base)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log base)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ -1 (log (/ -1 re)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 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 (sqrt (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/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log base) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (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 re 2))))))
#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 (sqrt (pow re 2)) 2))) (* (log base) (log (sqrt (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow re 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow re 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow re 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow re 2)) 6))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log (neg im)) (log base)) #s(hole binary64 (/ (log (neg im)) (log base))))
#s(approx (log (neg im)) #s(hole binary64 (log (neg im))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (pow re 2))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log base)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log base) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log base) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log base) (log (sqrt (pow re 2)))))))
#s(approx (/ (log base) (log (neg im))) #s(hole binary64 (/ (log base) (log (neg im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ 1 (log (sqrt (pow re 2))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ 1 (log (sqrt (pow re 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ 1 (log (sqrt (pow re 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 1/8 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (+ (* 1/6 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))) (+ (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* 1/4 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ 1 (log (sqrt (pow re 2)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log (sqrt (pow (fabs re) 2))) (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log base) (pow (sqrt (pow (fabs re) 2)) 2)))) (/ (log (sqrt (pow (fabs re) 2))) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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) (* (log base) (pow (sqrt (pow (fabs re) 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow (fabs re) 2)) 2)))))) (/ (log (sqrt (pow (fabs re) 2))) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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) (* (log base) (pow (sqrt (pow (fabs re) 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow (fabs re) 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow (fabs re) 2)) 2)))))) (/ (log (sqrt (pow (fabs re) 2))) (log base)))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log (sqrt (pow (fabs re) 2))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* 1/2 (/ (* (pow im 2) (log base)) (pow (sqrt (pow (fabs re) 2)) 2))) (* (log base) (log (sqrt (pow (fabs re) 2)))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow (fabs re) 2)))) (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (log base)) (pow (sqrt (pow (fabs re) 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow (fabs re) 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow (fabs re) 2)))) (* (pow im 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow (fabs re) 2)) 2))) (* (pow im 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow (fabs re) 2)) 4))) (* 1/6 (/ (* (pow im 2) (log base)) (pow (sqrt (pow (fabs re) 2)) 6))))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (log (sqrt (pow (fabs re) 2)))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow (fabs re) 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 2))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow (fabs re) 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow (fabs re) 2)) 2))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow (fabs re) 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow (fabs re) 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow (fabs re) 2)) 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (sqrt (pow (fabs re) 2))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (+ (sqrt (pow (fabs re) 2)) (* 1/2 (/ (pow im 2) (sqrt (pow (fabs re) 2)))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (+ (sqrt (pow (fabs re) 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 3))) (* 1/2 (/ 1 (sqrt (pow (fabs re) 2)))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (+ (sqrt (pow (fabs re) 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow (fabs re) 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow (fabs re) 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow (fabs re) 2)))))))))
#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 (/ (log (neg im)) (log base)) #s(hole binary64 (* -1 (/ (log (neg (/ 1 im))) (log base)))))
#s(approx (log (neg im)) #s(hole binary64 (* -1 (log (neg (/ 1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ 1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))))
#s(approx (/ (log base) (log (neg im))) #s(hole binary64 (* -1 (/ (log base) (log (neg (/ 1 im)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ -1 (log (/ 1 im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow (fabs re) 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow (fabs re) 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow (fabs re) 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow (fabs re) 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6)))) (pow im 6))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow (fabs re) 4) (pow im 4))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow (fabs re) 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6))) (pow im 6))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow (fabs re) 4) (pow im 4))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow (fabs re) 4) (pow im 4))) (+ (* 1/16 (/ (pow (fabs re) 6) (pow im 6))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))))
#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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log base) (log (/ -1 im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (- (+ (* -1 (/ (log base) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log base)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log base)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log base)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log base)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ -1 (log (/ -1 im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow (fabs re) 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow (fabs re) 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow (fabs re) 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow (fabs re) 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6)))) (pow im 6))) (* 1/2 (/ (* (pow (fabs re) 2) (log base)) (pow im 2))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow (fabs re) 4) (pow im 4))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow (fabs re) 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs re) 6)) (* 90 (pow (fabs re) 6))) (pow im 6))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow (fabs re) 2) (pow im 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow (fabs re) 4) (pow im 4))) (* 1/2 (/ (pow (fabs re) 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow (fabs re) 4) (pow im 4))) (+ (* 1/16 (/ (pow (fabs re) 6) (pow im 6))) (* 1/2 (/ (pow (fabs re) 2) (pow im 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 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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (/ (log base) (log (sqrt (+ (pow im 2) (pow re 2)))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) #s(hole binary64 (/ 1 (log (sqrt (+ (pow im 2) (pow re 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 (/ (log (neg im)) (log base)) #s(hole binary64 (* -1 (/ (log (neg im)) (log (/ 1 base))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (sqrt (+ (pow im 2) (pow re 2))))))))
#s(approx (/ (log base) (log (neg im))) #s(hole binary64 (* -1 (/ (log (/ 1 base)) (log (neg im))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs 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 (fabs re) 2)))) (log (/ 1 base))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs re))) (exp (log (fabs re)))) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log (sqrt (+ (pow im 2) (pow (fabs re) 2)))) (log (/ 1 base))))))
Outputs
(*.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (neg.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)))))
(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im 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 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base))) (*.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)))) (-.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 3 binary64)) (pow.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (-.f64 (*.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))))))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (neg.f64 #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))))
(+.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64)))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base))
(log.f64 (pow.f64 base (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fabs.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (neg.f64 (fabs.f64 re)) (pow.f64 im #s(literal 1 binary64)))
(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 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (fabs.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 re (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (neg.f64 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 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)))
(*.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(log.f64 (pow.f64 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 (neg.f64 im)) (log.f64 base)))
(*.f64 (log.f64 (neg.f64 im)) (/.f64 #s(literal 1 binary64) (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))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
(log.f64 (neg.f64 im))
(neg.f64 im)
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))))
(pow.f64 #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))))
#s(literal 1 binary64)
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
(*.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 (neg.f64 im))))
(/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
(/.f64 (log.f64 base) (log.f64 (neg.f64 im)))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(pow.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (neg.f64 (log.f64 base)) (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 base)))
(/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)))
(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))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (fabs.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (neg.f64 im) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 im (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (neg.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im re)
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))) (*.f64 im im))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (+.f64 (pow.f64 (*.f64 im im) #s(literal 3 binary64)) (pow.f64 (fabs.f64 re) #s(literal 6 binary64))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 im im (*.f64 re re))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 re) re))
(-.f64 (*.f64 im im) (neg.f64 (*.f64 re re)))
(+.f64 (*.f64 im im) (*.f64 re re))
(*.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(*.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (fabs.f64 re) (fabs.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 re #s(literal 2 binary64))
(exp.f64 (+.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))))
(exp.f64 (*.f64 (log.f64 (fabs.f64 re)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(*.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))))
(/.f64 (neg.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))) (neg.f64 (fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64)) (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))))
(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64)))
(+.f64 (/.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))) (/.f64 (*.f64 (atan2.f64 im re) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (atan2.f64 im re) #s(literal 0 binary64)) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base))) (*.f64 (*.f64 (atan2.f64 im re) #s(literal 0 binary64)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))) (-.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 3 binary64)) (pow.f64 (*.f64 (atan2.f64 im re) #s(literal 0 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (-.f64 (*.f64 (*.f64 (atan2.f64 im re) #s(literal 0 binary64)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))))))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (*.f64 (neg.f64 (atan2.f64 im re)) #s(literal 0 binary64)))
(-.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (neg.f64 (*.f64 (atan2.f64 im re) #s(literal 0 binary64))))
(+.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base))
(log.f64 (pow.f64 base (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fabs.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (neg.f64 (fabs.f64 re)) (pow.f64 im #s(literal 1 binary64)))
(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 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (fabs.f64 re) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 re (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(pow.f64 (*.f64 re re) #s(literal 1/2 binary64))
(sqrt.f64 (*.f64 re re))
(fabs.f64 (neg.f64 re))
(fabs.f64 (fabs.f64 re))
(fabs.f64 re)
(exp.f64 (log.f64 (fabs.f64 re)))
(+.f64 (cosh.f64 (log.f64 (fabs.f64 re))) (sinh.f64 (log.f64 (fabs.f64 re))))
(log.f64 (fabs.f64 re))
(pow.f64 (*.f64 re re) #s(literal 1/2 binary64))
(sqrt.f64 (*.f64 re re))
(fabs.f64 (neg.f64 re))
(fabs.f64 (fabs.f64 re))
(fabs.f64 re)
(exp.f64 (log.f64 (fabs.f64 re)))
(+.f64 (cosh.f64 (log.f64 (fabs.f64 re))) (sinh.f64 (log.f64 (fabs.f64 re))))
(*.f64 (atan2.f64 im re) #s(literal 0 binary64))
(atan2.f64 im re)
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64)))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 1 binary64)) (pow.f64 (log.f64 base) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 base) #s(literal 0 binary64))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
#s(literal 0 binary64)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (/.f64 (log.f64 (sqrt.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))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 base) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))) (/.f64 (log.f64 (sqrt.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))) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 base) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 (sqrt.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))) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 base) (pow.f64 (*.f64 im im) #s(literal 3 binary64))))) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 base) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (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 (*.f64 im im)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (pow.f64 (*.f64 im im) #s(literal 2 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 base) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 base) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (log.f64 base) (pow.f64 (*.f64 im im) #s(literal 2 binary64))) (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (pow.f64 (*.f64 im im) #s(literal 3 binary64))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 im im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (-.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 re re) (pow.f64 (*.f64 im im) #s(literal 2 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))) (/.f64 #s(literal 1/4 binary64) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))))))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (-.f64 (sqrt.f64 (*.f64 im im)) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (sqrt.f64 (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (sqrt.f64 (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) (pow.f64 (*.f64 im im) #s(literal 3/2 binary64))) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (sqrt.f64 (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 re re) (pow.f64 (*.f64 im im) #s(literal 5/2 binary64)))) (/.f64 #s(literal 1/8 binary64) (pow.f64 (*.f64 im im) #s(literal 3/2 binary64)))) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))))))
#s(approx re re)
#s(approx (* (atan2 im re) 0) #s(literal 0 binary64))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64))) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -1 binary64) (*.f64 (*.f64 re re) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 base) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64))))) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))) (fma.f64 #s(literal 1/8 binary64) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))) (*.f64 #s(literal 1/6 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 3 binary64))))))))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 base) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64))))) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1 binary64) (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))) (-.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))))))) (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))))) (/.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (+ (* im im) (* re re)) (*.f64 im im))
#s(approx (+ (* im im) (* re re)) (fma.f64 im im (*.f64 re re)))
#s(approx (* re re) (*.f64 re re))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
#s(approx (exp (log (fabs re))) (fabs.f64 re))
#s(approx (log (fabs re)) (log.f64 (fabs.f64 re)))
#s(approx (atan2 im re) (atan2.f64 im re))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (*.f64 #s(literal -1 binary64) (/.f64 (neg.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 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 base)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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))) (fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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))) (fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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 #s(literal -1 binary64) (*.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 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 re (-.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 re (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 re (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (neg.f64 (log.f64 re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (neg.f64 (log.f64 re))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1 binary64) (+.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 re))) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (*.f64 #s(literal -1 binary64) (+.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 re))) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))))) (neg.f64 (log.f64 re)))))) (pow.f64 re #s(literal 6 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 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))))) (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)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))))))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 re))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))))) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 re)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))))) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 re))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))))) (neg.f64 (log.f64 re)))))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))))) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 re))))))))
#s(approx (+ (* im im) (* re re)) (*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 base)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (*.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) (*.f64 re (-.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) (*.f64 re (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) (*.f64 re (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1 binary64) (+.f64 (/.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) re))) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (*.f64 #s(literal -1 binary64) (+.f64 (/.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) re))) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (pow.f64 re #s(literal 6 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 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (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)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (/.f64 (log.f64 (fabs.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 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 base) (*.f64 re re))) (/.f64 (log.f64 (fabs.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 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 base) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) (*.f64 re re)))) (/.f64 (log.f64 (fabs.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 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 base) (pow.f64 (fabs.f64 re) #s(literal 6 binary64))))) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 base) (*.f64 (*.f64 re re) (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) (*.f64 re re)))) (/.f64 (log.f64 (fabs.f64 re)) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 base) (log.f64 (fabs.f64 re))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)) (*.f64 (log.f64 base) (log.f64 (fabs.f64 re)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 base) (log.f64 (fabs.f64 re)) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 base) (*.f64 re re)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 base) (log.f64 (fabs.f64 re)) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 base) (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (pow.f64 (fabs.f64 re) #s(literal 6 binary64))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (fabs.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (-.f64 (log.f64 (fabs.f64 re)) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (fabs.f64 re)) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (fabs.f64 re)) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 im im) (pow.f64 (fabs.f64 re) #s(literal 6 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (fabs.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (-.f64 (fabs.f64 re) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (fabs.f64 re)))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (fabs.f64 re) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im im) (*.f64 (fabs.f64 re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (fabs.f64 re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (fabs.f64 re) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (pow.f64 (fabs.f64 re) #s(literal 5 binary64)))) (/.f64 #s(literal 1/8 binary64) (*.f64 (fabs.f64 re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (fabs.f64 re))))))
#s(approx im im)
#s(approx (/ (log (neg im)) (log base)) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
#s(approx (log (neg im)) (log.f64 (neg.f64 im)))
#s(approx (neg im) (*.f64 #s(literal -1 binary64) im))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (fabs.f64 re))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 re re))) (/.f64 (log.f64 base) (log.f64 (fabs.f64 re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1 binary64) (*.f64 (*.f64 im im) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (fabs.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 re re))))) (/.f64 (log.f64 base) (log.f64 (fabs.f64 re)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (fabs.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (*.f64 (log.f64 (fabs.f64 re)) (*.f64 re re))) (fma.f64 #s(literal 1/8 binary64) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (fabs.f64 re)) #s(literal 3 binary64)) (pow.f64 (fabs.f64 re) #s(literal 6 binary64)))) (*.f64 #s(literal 1/6 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (pow.f64 (fabs.f64 re) #s(literal 6 binary64))))))))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 base) (*.f64 (pow.f64 (log.f64 (fabs.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 re re))))) (/.f64 (log.f64 base) (log.f64 (fabs.f64 re)))))
#s(approx (/ (log base) (log (neg im))) (/.f64 (log.f64 base) (log.f64 (neg.f64 im))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal 1 binary64) (log.f64 (fabs.f64 re))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (log.f64 (fabs.f64 re)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (fma.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (pow.f64 (log.f64 (fabs.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 (fabs.f64 re)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (fma.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1 binary64) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (pow.f64 (log.f64 (fabs.f64 re)) #s(literal 3 binary64)) (pow.f64 (fabs.f64 re) #s(literal 6 binary64)))) (-.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (pow.f64 (fabs.f64 re) #s(literal 6 binary64)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (pow.f64 (log.f64 (fabs.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))) (*.f64 (log.f64 (fabs.f64 re)) (*.f64 re re))))))) (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (pow.f64 (log.f64 (fabs.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 (fabs.f64 re)) (log.f64 (fabs.f64 re))) (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 (fabs.f64 re)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (fabs.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 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 base) (*.f64 re re))) (/.f64 (log.f64 (fabs.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 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 base) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) (*.f64 re re)))) (/.f64 (log.f64 (fabs.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 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 base) (pow.f64 (fabs.f64 re) #s(literal 6 binary64))))) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 base) (*.f64 (*.f64 re re) (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 base) (*.f64 re re)))) (/.f64 (log.f64 (fabs.f64 re)) (log.f64 base))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 base) (log.f64 (fabs.f64 re))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 re re)) (*.f64 (log.f64 base) (log.f64 (fabs.f64 re)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 base) (log.f64 (fabs.f64 re)) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 base) (*.f64 re re)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 (log.f64 base) (log.f64 (fabs.f64 re)) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 base) (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (log.f64 base) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 base)) (pow.f64 (fabs.f64 re) #s(literal 6 binary64))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (fabs.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (-.f64 (log.f64 (fabs.f64 re)) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (fabs.f64 re)) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (fabs.f64 re)) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 im im) (pow.f64 (fabs.f64 re) #s(literal 6 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (fabs.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (-.f64 (fabs.f64 re) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (fabs.f64 re)))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (fabs.f64 re) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im im) (*.f64 (fabs.f64 re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (fabs.f64 re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (fabs.f64 re) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (pow.f64 (fabs.f64 re) #s(literal 5 binary64)))) (/.f64 #s(literal 1/8 binary64) (*.f64 (fabs.f64 re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (fabs.f64 re))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (*.f64 #s(literal -1 binary64) (/.f64 (neg.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 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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))) (fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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))) (fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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 #s(literal -1 binary64) (*.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 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 im (-.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))))
#s(approx (/ (log (neg im)) (log base)) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 base))))
#s(approx (log (neg im)) (*.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (neg.f64 (log.f64 im)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (neg.f64 (log.f64 im))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1 binary64) (+.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 im))) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (*.f64 #s(literal -1 binary64) (+.f64 (/.f64 (log.f64 base) (neg.f64 (log.f64 im))) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))))) (neg.f64 (log.f64 im)))))) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))))))))))
#s(approx (/ (log base) (log (neg im))) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))))) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (*.f64 (*.f64 im im) (*.f64 im im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))))) (neg.f64 (log.f64 im)))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))))))))
#s(approx (+ (* im im) (* re re)) (*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#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 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 (fabs.f64 re) #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 (fabs.f64 re) #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 (fabs.f64 re) #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 im (-.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 (fabs.f64 re) #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 base)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.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 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (*.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) (*.f64 im (-.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (fma.f64 #s(literal -1 binary64) (+.f64 (/.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))))) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (-.f64 (*.f64 #s(literal -1 binary64) (+.f64 (/.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 base)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))))) (*.f64 (*.f64 im im) (*.f64 im im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #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))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 base)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 base)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 base))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 (fabs.f64 re) #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 base))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 base))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 base) (*.f64 (pow.f64 (fabs.f64 re) #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 base)) (*.f64 im im)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 (fabs.f64 re) #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) (*.f64 im (-.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 #s(literal -1 binary64) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 (fabs.f64 re) #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))))
#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 (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (*.f64 #s(literal -1 binary64) (/.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)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (log.f64 base)))))
#s(approx (log base) (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 base))))
#s(approx (* (log base) (log base)) (*.f64 (log.f64 base) (log.f64 base)))
#s(approx (/ (log (neg im)) (log base)) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (neg.f64 im)) (neg.f64 (log.f64 base)))))
#s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
#s(approx (/ (log base) (log (neg im))) (*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 base)) (log.f64 (neg.f64 im)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 #s(literal -1 binary64) (/.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)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (log.f64 base)))))

eval49.0ms (1%)

Memory
-9.4MiB live, 124.2MiB allocated; 20ms collecting garbage
Compiler

Compiled 7 511 to 2 078 computations (72.3% saved)

prune88.0ms (1.8%)

Memory
1.3MiB live, 55.4MiB allocated; 7ms collecting garbage
Pruning

33 alts after pruning (26 fresh and 7 done)

PrunedKeptTotal
New34811359
Fresh41519
Picked235
Done044
Total35433387
Accuracy
99.9%
Counts
387 → 33
Alt Table
Click to see full alt table
StatusAccuracyProgram
54.6%
(/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
54.5%
(/.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
99.0%
(/.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 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
99.1%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
✓99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
46.0%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
51.3%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
56.0%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
55.8%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))) (*.f64 (log.f64 base) (log.f64 base)))
10.2%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 base) (log.f64 (fabs.f64 re)))) (*.f64 (log.f64 base) (log.f64 base)))
98.3%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (neg.f64 (log.f64 im))))) (*.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 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (*.f64 (log.f64 base) (log.f64 base)))
✓56.0%
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
55.9%
(/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
99.1%
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))))))
55.9%
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (*.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
10.2%
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) #s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal 1 binary64) (log.f64 (fabs.f64 re))))))
10.2%
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) #s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 re))))))
✓0.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))))
10.2%
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (fabs.f64 re)))))
27.9%
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64)))
✓56.2%
#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 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.2%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 re) (log.f64 base)))
✓98.6%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
10.2%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 re))))
98.5%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 im))))
56.1%
#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)))) (/.f64 #s(literal 1 binary64) (log.f64 base))))
0.0%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 (neg.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
10.2%
#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) (log.f64 base))))
98.5%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 base))))
0.0%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log base) (log base))) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 base))))
Compiler

Compiled 1 491 to 923 computations (38.1% saved)

regimes107.0ms (2.2%)

Memory
18.8MiB live, 148.0MiB allocated; 14ms collecting garbage
Counts
57 → 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))) (/.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 im) (/.f64 #s(literal 1 binary64) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 re) (/.f64 #s(literal 1 binary64) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (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 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 re))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 (neg.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (fabs.f64 re)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re 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)) (* (log base) (log base))) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 base))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (*.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) #s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 re))))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) #s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal 1 binary64) (log.f64 (fabs.f64 re))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 base) (log.f64 (fabs.f64 re)))) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (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 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (*.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 (fabs.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 (fabs.f64 re)) (log.f64 base))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #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 (log.f64 base) (log.f64 base)))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (*.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (hypot.f64 im re))))))
(/.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 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64)))
(/.f64 (log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (+.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 (pow.f64 (log.f64 base) #s(literal -1 binary64)) (pow.f64 (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #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))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (log.f64 (pow.f64 base (log.f64 base))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 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))) (pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.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 (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 (log.f64 base) (log.f64 base))))
(/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.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 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 3 binary64)) #s(literal 0 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 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:

46.0ms
(log.f64 base)
16.0ms
im
15.0ms
re
14.0ms
base
13.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
AccuracySegmentsBranch
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%1re
99.2%1im
99.2%1base
Compiler

Compiled 27 to 31 computations (-14.8% saved)

regimes61.0ms (1.3%)

Memory
-0.1MiB live, 87.6MiB allocated; 32ms collecting garbage
Accuracy

Total -63.1b remaining (-7033.4%)

Threshold costs -63.1b (-7033.4%)

Counts
30 → 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))) (/.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 im) (/.f64 #s(literal 1 binary64) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 re) (/.f64 #s(literal 1 binary64) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 #s(literal 1 binary64) (/.f64 (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 #s(literal 1 binary64) (/.f64 (log.f64 base) (log.f64 re))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 (neg.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (neg.f64 im)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (log.f64 base) (log.f64 (fabs.f64 re)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (/.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re 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)) (* (log base) (log base))) (*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 base))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (* (log base) (log base)) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0)) (*.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) #s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 re))))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) #s(approx (/ (log base) (* (log base) (log (sqrt (+ (* im im) (* re re)))))) (/.f64 #s(literal 1 binary64) (log.f64 (fabs.f64 re))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 base) (log.f64 (fabs.f64 re)))) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (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 (log.f64 base) (log.f64 (sqrt.f64 (*.f64 im im))))) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 base) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (*.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 (fabs.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 (fabs.f64 re)) (log.f64 base))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (/.f64 (log.f64 base) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 base) (log.f64 base)) (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))))
Outputs
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (log.f64 base)))
Calls

5 calls:

23.0ms
re
14.0ms
(log.f64 base)
8.0ms
base
8.0ms
im
7.0ms
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
Results
AccuracySegmentsBranch
98.6%1(log.f64 base)
98.6%1(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
98.6%1re
98.6%1im
98.6%1base
Compiler

Compiled 27 to 31 computations (-14.8% saved)

derivations97.0ms (2%)

Memory
4.7MiB live, 94.3MiB allocated; 13ms collecting garbage
Stop Event
1×fuel
Compiler

Compiled 37 to 30 computations (18.9% saved)

preprocess29.0ms (0.6%)

Memory
13.0MiB live, 69.2MiB allocated; 12ms collecting garbage
Compiler

Compiled 305 to 270 computations (11.5% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...