math.log/2 on complex, real part

Time bar (total: 5.3s)

start0.0ms (0%)

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

analyze175.0ms (3.3%)

Memory
-2.4MiB live, 419.0MiB allocated; 55ms 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.5s (27.9%)

Memory
74.3MiB live, 2 458.2MiB allocated; 478ms collecting garbage
Samples
1.1s8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 744.0ms
ival-log: 222.0ms (29.8% of total)
ival-hypot: 166.0ms (22.3% of total)
ival-mult!: 144.0ms (19.3% of total)
ival-atan2: 109.0ms (14.6% of total)
ival-div!: 56.0ms (7.5% of total)
ival-add!: 46.0ms (6.2% of total)
adjust: 1.0ms (0.1% of total)
Bogosity

preprocess92.0ms (1.7%)

Memory
-19.3MiB live, 28.1MiB allocated; 5ms collecting garbage
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
079197
1331177
21729142
Stop Event
1×node-limit
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶47.4%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.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)

series143.0ms (2.7%)

Memory
26.9MiB live, 229.8MiB allocated; 80ms 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
89.0ms
base
@0
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
20.0ms
base
@-inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0))
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))

rewrite211.0ms (4%)

Memory
0.3MiB live, 231.2MiB allocated; 24ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
05254499
05483946
132383728
083243013
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
130 → 402
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))))
(/.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)) #s(literal 1 binary64)) (*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (*.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)) #s(literal 1 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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 (neg.f64 (neg.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)))) (neg.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base)))))
(/.f64 (neg.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64))) (neg.f64 (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 (*.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))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (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 (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 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 im) im))
(-.f64 (*.f64 re re) (neg.f64 (*.f64 im im)))
(-.f64 (*.f64 im im) (neg.f64 (*.f64 re re)))
(+.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 (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 (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 (/.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 (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 (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 (/.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 re re) (/.f64 (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)) (*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.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)) (*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (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)))

eval48.0ms (0.9%)

Memory
6.1MiB live, 102.8MiB allocated; 17ms collecting garbage
Compiler

Compiled 5 002 to 1 899 computations (62% saved)

prune20.0ms (0.4%)

Memory
11.4MiB live, 55.0MiB allocated; 5ms collecting garbage
Pruning

17 alts after pruning (17 fresh and 0 done)

PrunedKeptTotal
New33517352
Fresh000
Picked101
Done000
Total33617353
Accuracy
99.7%
Counts
353 → 17
Alt Table
Click to see full alt table
StatusAccuracyProgram
45.7%
(/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (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))))
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.3%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (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))))
▶47.4%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
22.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))))
24.3%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
45.7%
(/.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 1 binary64)) (*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
45.7%
(/.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)) #s(literal 1 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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))))
10.7%
(/.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.1%
(/.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))))
47.4%
(*.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))))
▶47.6%
#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.7%
#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.3%
#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 826 to 696 computations (15.7% saved)

series569.0ms (10.7%)

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

9 calls:

TimeVariablePointExpression
167.0ms
im
@inf
((/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (log (fabs im)) (fabs im) im re (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 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 re) (* im im)) (* im im) (/ (- (pow (log base) 4) 0) (* (log base) (log base))) (- (pow (log base) 4) 0) (pow (log base) 4) 4)
151.0ms
im
@-inf
((/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (log (fabs im)) (fabs im) im re (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 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 re) (* im im)) (* im im) (/ (- (pow (log base) 4) 0) (* (log base) (log base))) (- (pow (log base) 4) 0) (pow (log base) 4) 4)
86.0ms
im
@0
((/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (log (fabs im)) (fabs im) im re (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 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 re) (* im im)) (* im im) (/ (- (pow (log base) 4) 0) (* (log base) (log base))) (- (pow (log base) 4) 0) (pow (log base) 4) 4)
59.0ms
base
@inf
((/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (log (fabs im)) (fabs im) im re (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 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 re) (* im im)) (* im im) (/ (- (pow (log base) 4) 0) (* (log base) (log base))) (- (pow (log base) 4) 0) (pow (log base) 4) 4)
53.0ms
base
@0
((/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (log (fabs im)) (fabs im) im re (log base) base (* (atan2 im re) 0) (atan2 im re) 0 (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log im) (log base)) (log im) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (log base)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (- (pow (log base) 4) 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 re) (* im im)) (* im im) (/ (- (pow (log base) 4) 0) (* (log base) (log base))) (- (pow (log base) 4) 0) (pow (log base) 4) 4)

rewrite161.0ms (3%)

Memory
13.0MiB live, 195.5MiB allocated; 26ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
07886553
08535048
154344906
083944643
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
208 → 1 025
Calls
Call 1
Inputs
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (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 im))) re)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (log.f64 base))
(log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)
(exp.f64 (log.f64 (fabs.f64 im)))
(log.f64 (fabs.f64 im))
(fabs.f64 im)
im
re
(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 (+.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)
(/.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 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64)))
(*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base))
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 im im)
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log (sqrt (pow (fabs im) 2))) (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (fabs im) 2)) 2)))) (/ (log (sqrt (pow (fabs im) 2))) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (fabs im) 2)) 4)))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow (fabs im) 2)) 2)))))) (/ (log (sqrt (pow (fabs im) 2))) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (fabs im) 2)) 6)))) (* 1/4 (/ 1 (* (log base) (pow (sqrt (pow (fabs im) 2)) 4)))))) (* 1/2 (/ 1 (* (log base) (pow (sqrt (pow (fabs im) 2)) 2)))))) (/ (log (sqrt (pow (fabs im) 2))) (log base)))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log (sqrt (pow (fabs im) 2))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log base)) (pow (sqrt (pow (fabs im) 2)) 2))) (* (log base) (log (sqrt (pow (fabs im) 2)))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow (fabs im) 2)))) (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (log base)) (pow (sqrt (pow (fabs im) 2)) 4))) (* 1/2 (/ (log base) (pow (sqrt (pow (fabs im) 2)) 2))))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* (log base) (log (sqrt (pow (fabs im) 2)))) (* (pow re 2) (+ (* 1/2 (/ (log base) (pow (sqrt (pow (fabs im) 2)) 2))) (* (pow re 2) (+ (* -1/4 (/ (log base) (pow (sqrt (pow (fabs im) 2)) 4))) (* 1/6 (/ (* (pow re 2) (log base)) (pow (sqrt (pow (fabs im) 2)) 6))))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (log (sqrt (pow (fabs im) 2)))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (+ (log (sqrt (pow (fabs im) 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow (fabs im) 2)) 2))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (+ (log (sqrt (pow (fabs im) 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow (sqrt (pow (fabs im) 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow (fabs im) 2)) 2))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (+ (log (sqrt (pow (fabs im) 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow (sqrt (pow (fabs im) 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow (fabs im) 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow (fabs im) 2)) 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (sqrt (pow (fabs im) 2))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (+ (sqrt (pow (fabs im) 2)) (* 1/2 (/ (pow re 2) (sqrt (pow (fabs im) 2)))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (+ (sqrt (pow (fabs im) 2)) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow (sqrt (pow (fabs im) 2)) 3))) (* 1/2 (/ 1 (sqrt (pow (fabs im) 2)))))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (+ (sqrt (pow (fabs im) 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow (sqrt (pow (fabs im) 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow (fabs im) 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow (fabs 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 (/ (+ (* (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 (+ (* im im) (* re re)))) #s(hole binary64 (log (sqrt (pow im 2)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log (sqrt (pow im 2))) (* 1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #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 (+ (* im im) (* re re)))) #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 (+ (* im im) (* re re))) #s(hole binary64 (sqrt (pow im 2))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ (sqrt (pow im 2)) (* 1/2 (/ (pow re 2) (sqrt (pow im 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #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 (+ (* im im) (* re re))) #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 (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow (fabs im) 2) (* (pow re 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow (fabs im) 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow (fabs im) 2) (* (pow re 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow (fabs im) 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs im) 6)) (* 90 (pow (fabs im) 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow (fabs im) 2) (* (pow re 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 re))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow (fabs im) 2) (log base)) (pow re 2))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow (fabs im) 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow (fabs im) 2) (log base)) (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow (fabs im) 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow (fabs im) 6)) (* 90 (pow (fabs im) 6)))) (pow re 6))) (* 1/2 (/ (* (pow (fabs im) 2) (log base)) (pow re 2))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow (fabs im) 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow (fabs im) 4) (pow re 4))) (* 1/2 (/ (pow (fabs im) 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow (fabs im) 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs im) 6)) (* 90 (pow (fabs im) 6))) (pow re 6))) (* 1/2 (/ (pow (fabs im) 2) (pow re 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow (fabs im) 2) (pow re 2)))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow (fabs im) 4) (pow re 4))) (* 1/2 (/ (pow (fabs im) 2) (pow re 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow (fabs im) 4) (pow re 4))) (+ (* 1/16 (/ (pow (fabs im) 6) (pow re 6))) (* 1/2 (/ (pow (fabs 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))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (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/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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow (fabs im) 2) (* (pow re 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow (fabs im) 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow (fabs im) 2) (* (pow re 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow (fabs im) 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs im) 6)) (* 90 (pow (fabs im) 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow (fabs im) 2) (* (pow re 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ -1 re))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow (fabs im) 2) (log base)) (pow re 2))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow (fabs im) 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow (fabs im) 2) (log base)) (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow (fabs im) 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow (fabs im) 6)) (* 90 (pow (fabs im) 6)))) (pow re 6))) (* 1/2 (/ (* (pow (fabs im) 2) (log base)) (pow re 2))))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow (fabs im) 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow (fabs im) 4) (pow re 4))) (* 1/2 (/ (pow (fabs im) 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow (fabs im) 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow (fabs im) 6)) (* 90 (pow (fabs im) 6))) (pow re 6))) (* 1/2 (/ (pow (fabs im) 2) (pow re 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow (fabs im) 2) (pow re 2))))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow (fabs im) 4) (pow re 4))) (* 1/2 (/ (pow (fabs im) 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow (fabs im) 4) (pow re 4))) (+ (* 1/16 (/ (pow (fabs im) 6) (pow re 6))) (* 1/2 (/ (pow (fabs 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))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (/ (log (sqrt (+ (pow re 2) (pow (fabs im) 2)))) (log base))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* (log base) (log (sqrt (+ (pow re 2) (pow (fabs im) 2)))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) #s(hole binary64 (log (sqrt (+ (pow re 2) (pow (fabs im) 2))))))
#s(approx (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) #s(hole binary64 (sqrt (+ (pow re 2) (pow (fabs im) 2)))))
#s(approx (exp (log (fabs im))) #s(hole binary64 (fabs im)))
#s(approx (log (fabs im)) #s(hole binary64 (log (fabs im))))
#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 (/ (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 im) (log base)) #s(hole binary64 (/ (log im) (log base))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #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 (+ (* im im) (* re re)))) #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 (+ (* im im) (* re re))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #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 (+ (* im im) (* re re))) #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 (+ (* (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)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))))
#s(approx (log im) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log base) (log (/ 1 im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))))
#s(approx (+ (* (log (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 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 (/ (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 (- (pow (log base) 4) 0) #s(hole binary64 (pow (log base) 4)))
#s(approx (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (sqrt (+ (pow re 2) (pow (fabs im) 2)))) (log (/ 1 base))))))
#s(approx (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) #s(hole binary64 (* -1 (* (log (sqrt (+ (pow re 2) (pow (fabs im) 2)))) (log (/ 1 base))))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) #s(hole binary64 (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))))
#s(approx (/ (log im) (log base)) #s(hole binary64 (* -1 (/ (log im) (log (/ 1 base))))))
#s(approx (+ (* (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 (- (pow (log base) 4) 0) #s(hole binary64 (pow (log (/ 1 base)) 4)))
Outputs
(*.f64 (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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(literal 0 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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)) #s(literal 0 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #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)) #s(literal 0 binary64))
(+.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base))))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base)))
(*.f64 #s(literal 1/2 binary64) (log.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)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (neg.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (neg.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 (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)) (fabs.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 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.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 (fabs.f64 im)) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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)) (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 (neg.f64 (fabs.f64 im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.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) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.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) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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) (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 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (fabs.f64 im) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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) (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 re (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re im)
(hypot.f64 im (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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 (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (sqrt.f64 (*.f64 re re)))
(hypot.f64 im re)
(exp.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1/2 binary64)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1/2 binary64)) (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (neg.f64 im) #s(literal 1/2 binary64)) (pow.f64 (neg.f64 im) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (fabs.f64 im) #s(literal 1/2 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)))
(pow.f64 (fabs.f64 im) #s(literal 1 binary64))
(pow.f64 (*.f64 im im) #s(literal 1/2 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fabs.f64 im)))
(sqrt.f64 (*.f64 im im))
(fabs.f64 (neg.f64 im))
(fabs.f64 im)
(exp.f64 (/.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))
(exp.f64 (/.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (/.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (fabs.f64 im)))
(+.f64 (/.f64 (+.f64 (fabs.f64 im) (/.f64 #s(literal 1 binary64) (fabs.f64 im))) #s(literal 2 binary64)) (/.f64 (-.f64 (fabs.f64 im) (/.f64 #s(literal 1 binary64) (fabs.f64 im))) #s(literal 2 binary64)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im)))
(log.f64 (fabs.f64 im))
(*.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1/2 binary64)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1/2 binary64)) (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (neg.f64 im) #s(literal 1/2 binary64)) (pow.f64 (neg.f64 im) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (fabs.f64 im) #s(literal 1/2 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)))
(pow.f64 (fabs.f64 im) #s(literal 1 binary64))
(pow.f64 (*.f64 im im) #s(literal 1/2 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fabs.f64 im)))
(sqrt.f64 (*.f64 im im))
(fabs.f64 (neg.f64 im))
(fabs.f64 im)
(exp.f64 (/.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))
(exp.f64 (/.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (/.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(exp.f64 (log.f64 (fabs.f64 im)))
(+.f64 (/.f64 (+.f64 (fabs.f64 im) (/.f64 #s(literal 1 binary64) (fabs.f64 im))) #s(literal 2 binary64)) (/.f64 (-.f64 (fabs.f64 im) (/.f64 #s(literal 1 binary64) (fabs.f64 im))) #s(literal 2 binary64)))
im
re
(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 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.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))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) base) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #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 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.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))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) base) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #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 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(*.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)))
(/.f64 (log.f64 im) (log.f64 base))
(/.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 base)))
(neg.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 base)))
(*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(neg.f64 (neg.f64 (log.f64 im)))
(log.f64 im)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (neg.f64 (log.f64 base)))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base))
(*.f64 #s(literal 1/2 binary64) (log.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)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (neg.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (neg.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 (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)) (fabs.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 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.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 (fabs.f64 im)) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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)) (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 (neg.f64 (fabs.f64 im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.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) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.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) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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) (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 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (fabs.f64 im) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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) (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 re (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re im)
(hypot.f64 im (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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 (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (sqrt.f64 (*.f64 re re)))
(hypot.f64 im re)
(exp.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (*.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 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.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 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (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 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 re) re))
(-.f64 (*.f64 im im) (neg.f64 (*.f64 re re)))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 im) im))
(-.f64 (*.f64 re re) (neg.f64 (*.f64 im im)))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(*.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 (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 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (sqrt.f64 (*.f64 re 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)))
(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 (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 (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 (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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(literal 0 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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)) #s(literal 0 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #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)) #s(literal 0 binary64))
(+.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base))))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base)))
(*.f64 #s(literal 1/2 binary64) (log.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)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (neg.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (neg.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 (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)) (fabs.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 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.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 (fabs.f64 im)) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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)) (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 (neg.f64 (fabs.f64 im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.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) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.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) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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) (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 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (fabs.f64 im) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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) (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 re (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re im)
(hypot.f64 im (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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 (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (sqrt.f64 (*.f64 re re)))
(hypot.f64 im re)
(exp.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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(literal 0 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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)) #s(literal 0 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 0 binary64)))))
(fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64))
(fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #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)) #s(literal 0 binary64))
(+.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base))))
(log.f64 (/.f64 (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (log.f64 base)))
(*.f64 #s(literal 1/2 binary64) (log.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)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (neg.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (neg.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) im)
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 (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)) (fabs.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 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.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 (fabs.f64 im)) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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)) (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 (neg.f64 (fabs.f64 im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.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) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.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) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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) (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 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.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)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (fabs.f64 im) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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) (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 re (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re im)
(hypot.f64 im (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(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 (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (sqrt.f64 (*.f64 re re)))
(hypot.f64 im re)
(exp.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (*.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 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.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 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (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 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 re) re))
(-.f64 (*.f64 im im) (neg.f64 (*.f64 re re)))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 im) im))
(-.f64 (*.f64 re re) (neg.f64 (*.f64 im im)))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (fabs.f64 (fabs.f64 im)) #s(literal 1 binary64)) (pow.f64 (fabs.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 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)))
(*.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 im im)
(pow.f64 (neg.f64 (fabs.f64 im)) #s(literal 2 binary64))
(pow.f64 (fabs.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)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 2 binary64)) #s(literal 1 binary64)))
(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 (log.f64 (*.f64 im im)))
(exp.f64 (*.f64 (log.f64 (fabs.f64 im)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (log.f64 (*.f64 im im))) (sinh.f64 (log.f64 (*.f64 im im))))
(+.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))))
(*.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (log.f64 base))) (exp.f64 (log.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.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))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(-.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) base) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #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 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 4 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 4 binary64))
(pow.f64 (*.f64 (log.f64 base) (neg.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 4 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (+.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(exp.f64 (fma.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 4 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 base))) #s(literal 4 binary64))
(pow.f64 (*.f64 (log.f64 base) (neg.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 4 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64))
(/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (-.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64)) (+.f64 (pow.f64 (log.f64 base) #s(literal 8 binary64)) (+.f64 #s(literal 0 binary64) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)))))
(neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64))))
(fma.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(exp.f64 (fma.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))
(+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))))
#s(literal 4 binary64)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log.f64 (fabs.f64 im)))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 (fabs.f64 im))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (+ (* im im) (* re re))) (fabs.f64 im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 re re) (fabs.f64 im)) #s(literal 1/2 binary64) (fabs.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) (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 (+ (* im im) (* re re))) (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)
#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 (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log.f64 (fabs.f64 im)))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 (fabs.f64 im))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (+ (* im im) (* re re))) (fabs.f64 im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 re re) (fabs.f64 im)) #s(literal 1/2 binary64) (fabs.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) (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 (+ (* im im) (* re re))) (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 (+ (* im im) (* re re)) (*.f64 im im))
#s(approx (+ (* im im) (* re re)) (fma.f64 re re (*.f64 im im)))
#s(approx (* re re) (*.f64 re re))
#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 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 im im) (*.f64 (*.f64 re re) (log.f64 base))) #s(literal 1/2 binary64) (*.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 (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 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64) (*.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))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log.f64 re))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 im im) (*.f64 re re)) #s(literal 1/2 binary64) (*.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)))) (log.f64 re)))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.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 (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (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 im im) (*.f64 (*.f64 re re) (log.f64 base))) #s(literal 1/2 binary64) (*.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 (log.f64 re) (log.f64 base))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 im im) (*.f64 re re)) #s(literal 1/2 binary64) (*.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)))) (log.f64 re)))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.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 (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* im im) (* re re)) (*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re)))
#s(approx (+ (* (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 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64) (*.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))))))
#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 im im) (*.f64 (*.f64 re re) (log.f64 base))) #s(literal 1/2 binary64) (*.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 (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 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64) (*.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))))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log.f64 (neg.f64 re)))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 (neg.f64 re))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 im im) (*.f64 re re)) #s(literal 1/2 binary64) (*.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))))))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 re) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (*.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 (+ (* im im) (* re re))) (*.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))) (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 im im) (*.f64 (*.f64 re re) (log.f64 base))) #s(literal 1/2 binary64) (*.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 (log.f64 (neg.f64 re)) (log.f64 base))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 (neg.f64 re))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 im im) (*.f64 re re)) #s(literal 1/2 binary64) (*.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))))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 re) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (*.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 (+ (* im im) (* re re))) (*.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)) (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 im im) (log.f64 base)) (*.f64 re re)) #s(literal 1/2 binary64) (*.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))))))
#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 re re (*.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 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
#s(approx (sqrt (+ (* im im) (* re re))) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
#s(approx (exp (log (fabs im))) (fabs.f64 im))
#s(approx (log (fabs im)) (log.f64 (fabs.f64 im)))
#s(approx im im)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (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 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 base))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 base)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 base)))) (*.f64 im im) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 base))))
#s(approx (/ (log im) (log base)) (/.f64 (log.f64 im) (log.f64 base)))
#s(approx (log im) (log.f64 im))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log.f64 (sqrt.f64 (*.f64 re re))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (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 (sqrt.f64 (*.f64 re re)))))
#s(approx (sqrt (+ (* im im) (* re re))) (sqrt.f64 (*.f64 re re)))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 im im) (sqrt.f64 (*.f64 re re))) #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re))))
#s(approx (sqrt (+ (* im im) (* re re))) (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 (+ (* im im) (* re re))) (fma.f64 (fma.f64 (-.f64 (*.f64 (*.f64 (*.f64 im im) (pow.f64 (*.f64 re re) #s(literal -5/2 binary64))) #s(literal 1/16 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 (+ (* (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)) (*.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))))
#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 im) (log.f64 im))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 (+ (* im im) (* re re))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.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 (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (+ (* im im) (* re re)) (*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.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 (log.f64 base) (/.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 (*.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)) (+ (* (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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log.f64 (neg.f64 im)))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 (neg.f64 im))))
#s(approx (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (+.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 (+ (* im im) (* re re))) (neg.f64 im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (*.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 (+ (* im im) (* re re))) (*.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)) (*.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 (log.f64 base) (/.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 (*.f64 re re) (/.f64 (log.f64 base) (*.f64 im im))) #s(literal 1/2 binary64))))))
#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))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.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 (fma.f64 re re (*.f64 im im)))) (log.f64 base)))
#s(approx (- (pow (log base) 4) 0) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (neg.f64 (log.f64 base)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (neg.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
#s(approx (log base) (neg.f64 (neg.f64 (log.f64 base))))
#s(approx (+ (* (log base) (log base)) (* 0 0)) (*.f64 (log.f64 base) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (neg.f64 (/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (neg.f64 (log.f64 base)))))
#s(approx (/ (log im) (log base)) (/.f64 (log.f64 im) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (neg.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
#s(approx (- (pow (log base) 4) 0) (pow.f64 (log.f64 base) #s(literal 4 binary64)))

eval114.0ms (2.2%)

Memory
-21.7MiB live, 116.6MiB allocated; 76ms collecting garbage
Compiler

Compiled 6 362 to 2 446 computations (61.6% saved)

prune27.0ms (0.5%)

Memory
17.1MiB live, 62.6MiB allocated; 3ms collecting garbage
Pruning

26 alts after pruning (24 fresh and 2 done)

PrunedKeptTotal
New49715512
Fresh3912
Picked325
Done000
Total50326529
Accuracy
99.8%
Counts
529 → 26
Alt Table
Click to see full alt table
StatusAccuracyProgram
45.7%
(/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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.3%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (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))))
99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
▶99.3%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
47.1%
(/.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))))
47.6%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
22.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))))
47.4%
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
▶45.7%
(/.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 1 binary64)) (*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
45.7%
(/.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)) #s(literal 1 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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))))
10.7%
(/.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.1%
(/.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))))
47.4%
(*.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
47.4%
(*.f64 (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
✓47.6%
#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)))
24.5%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
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.7%
#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.3%
#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)))
47.1%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
47.5%
#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 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 base))))
98.2%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 base))))
Compiler

Compiled 1 221 to 1 035 computations (15.2% saved)

series318.0ms (6%)

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

9 calls:

TimeVariablePointExpression
85.0ms
base
@-inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (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) (atan2 im re) 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (fabs im)) (log base)) (log (fabs im)) (fabs im) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (* (atan2 im re) 0) (/ (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base)))) (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (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) 2 1 (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))
46.0ms
base
@0
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (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) (atan2 im re) 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (fabs im)) (log base)) (log (fabs im)) (fabs im) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (* (atan2 im re) 0) (/ (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base)))) (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (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) 2 1 (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))
42.0ms
base
@inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (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) (atan2 im re) 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (fabs im)) (log base)) (log (fabs im)) (fabs im) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (* (atan2 im re) 0) (/ (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base)))) (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (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) 2 1 (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))
26.0ms
im
@inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (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) (atan2 im re) 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (fabs im)) (log base)) (log (fabs im)) (fabs im) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (* (atan2 im re) 0) (/ (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base)))) (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (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) 2 1 (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))
26.0ms
im
@0
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (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) (atan2 im re) 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log re) (log base)) (log re) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (log (fabs im)) (log base)) (log (fabs im)) (fabs im) (+ (* (log base) (log base)) (* 0 0)) (* (log base) (log base)) (* 0 0) (/ (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (+ (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (* (atan2 im re) 0)) (* (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (log base)) (log (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re)))) (sqrt (+ (* (exp (log (fabs im))) (exp (log (fabs im)))) (* re re))) (exp (log (fabs im))) (* (atan2 im re) 0) (/ (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base)))) (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) (* (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) 2 1 (* (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0) (* (log base) (log base))) (+ (* (log base) (log (sqrt (+ (* im im) (* re re))))) 0))

rewrite289.0ms (5.5%)

Memory
0.2MiB live, 233.5MiB allocated; 73ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

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

eval62.0ms (1.2%)

Memory
13.7MiB live, 118.7MiB allocated; 23ms collecting garbage
Compiler

Compiled 8 251 to 2 250 computations (72.7% saved)

prune40.0ms (0.7%)

Memory
8.6MiB live, 99.6MiB allocated; 13ms collecting garbage
Pruning

41 alts after pruning (38 fresh and 3 done)

PrunedKeptTotal
New43722459
Fresh31619
Picked415
Done022
Total44441485
Accuracy
99.9%
Counts
485 → 41
Alt Table
Click to see full alt table
StatusAccuracyProgram
45.7%
(/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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.3%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
▶99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 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 (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))) (log.f64 base)) (log.f64 base)))
49.6%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (/.f64 (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))) (log.f64 base)) (log.f64 base)))
99.1%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
▶99.3%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
47.6%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
22.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))))
45.7%
(/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64)) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
45.7%
(/.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)) #s(literal 1 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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))))
10.7%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
98.1%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
▶0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
10.7%
(/.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.0%
(/.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
97.5%
(/.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 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #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))))))
98.1%
(/.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 (log.f64 base) (log.f64 base)))
49.5%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
46.7%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
46.7%
(/.f64 #s(approx (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (pow.f64 (*.f64 (neg.f64 (log.f64 im)) (log.f64 base)) #s(literal 2 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))))
46.7%
(/.f64 #s(approx (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (pow.f64 (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base)) #s(literal 2 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))))
45.6%
(*.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)))))
47.4%
(*.f64 (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
47.4%
(*.f64 (/.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (log.f64 base))
47.4%
(*.f64 (*.f64 (log.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))))
98.0%
(*.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 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
✓47.6%
#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)))
▶24.5%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
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.7%
#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.3%
#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)))
47.1%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
47.5%
#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 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 base))))
10.7%
#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.2%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 base))))
Compiler

Compiled 2 007 to 1 719 computations (14.3% saved)

series426.0ms (8%)

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

9 calls:

TimeVariablePointExpression
101.0ms
base
@-inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 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 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (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) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log base)) (log (/ -1 re))) (neg (log base)) (log (/ -1 re)) (/ -1 re) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ (pow (log base) 4) (* (log base) (log base))) (* (log base) (log base)))
92.0ms
base
@inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 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 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (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) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log base)) (log (/ -1 re))) (neg (log base)) (log (/ -1 re)) (/ -1 re) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ (pow (log base) 4) (* (log base) (log base))) (* (log base) (log base)))
61.0ms
base
@0
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 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 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (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) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log base)) (log (/ -1 re))) (neg (log base)) (log (/ -1 re)) (/ -1 re) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ (pow (log base) 4) (* (log base) (log base))) (* (log base) (log base)))
51.0ms
im
@inf
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 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 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (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) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log base)) (log (/ -1 re))) (neg (log base)) (log (/ -1 re)) (/ -1 re) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ (pow (log base) 4) (* (log base) (log base))) (* (log base) (log base)))
38.0ms
re
@0
((/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 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 0 (/ (/ (pow (log base) 4) (log base)) (log base)) (/ (pow (log base) 4) (log base)) (pow (log base) 4) 4 (/ (+ (* (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) (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/ (log (sqrt (+ (* im im) (* re re)))) (exp (* (log (log base)) 1))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (exp (* (log (log base)) 1)) (* (log (log base)) 1) (log (log base)) 1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (/ (pow (log base) 4) (log base)) (log base))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (neg (log base)) (log (/ -1 re))) (neg (log base)) (log (/ -1 re)) (/ -1 re) -1 (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (/ (pow (log base) 4) (* (log base) (log base)))) (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (* (atan2 im re) 0) (atan2 im re) (/ (pow (log base) 4) (* (log base) (log base))) (* (log base) (log base)))

rewrite190.0ms (3.6%)

Memory
36.8MiB live, 311.4MiB allocated; 44ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
06004341
06593828
134953446
087703326
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
173 → 768
Calls
Call 1
Inputs
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #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(literal 0 binary64)
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
#s(literal 4 binary64)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 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)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))))
(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)
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))
(*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))
(log.f64 (log.f64 base))
#s(literal 1 binary64)
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(neg.f64 (log.f64 base))
(log.f64 (/.f64 #s(literal -1 binary64) re))
(/.f64 #s(literal -1 binary64) re)
#s(literal -1 binary64)
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(+.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)
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (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)) 0) (/ (/ (pow (log base) 4) (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)) 0) (/ (/ (pow (log base) 4) (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)) 0) #s(hole binary64 (* (log base) (log (sqrt (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 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)) 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)) 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 (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (* (neg (log base)) (log (/ -1 re))) #s(hole binary64 (* (log base) (log (neg re)))))
#s(approx (log (/ -1 re)) #s(hole binary64 (* -1 (log (neg re)))))
#s(approx (/ -1 re) #s(hole binary64 (/ -1 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)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (* -1 (* (log base) (log (/ 1 re))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (* (neg (log base)) (log (/ -1 re))) #s(hole binary64 (* -1 (* (log base) (log (neg (/ 1 re)))))))
#s(approx (log (/ -1 re)) #s(hole binary64 (log (neg (/ 1 re)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log base))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log base)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (* -1 (* (log base) (log (/ -1 re))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (log base)) (pow re 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (log base)) (pow re 2))))))))
#s(approx (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 (/ -1 re)) #s(hole binary64 (log (/ -1 re))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (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)) 0) (/ (/ (pow (log base) 4) (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)) 0) (/ (/ (pow (log base) 4) (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)) 0) #s(hole binary64 (* (log base) (log (sqrt (pow re 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 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)) 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)) 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 (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (* -1 (* (log base) (log (/ 1 im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))))
#s(approx (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 (+ (* 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)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log base)))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base))))))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log base))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log base)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log base)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log base)))))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (* -1 (* (log base) (log (/ -1 im))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2)))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (+ (* -1 (* (log base) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (log base)) (pow im 4))) (+ (* 1/720 (/ (* (log base) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (log base)) (pow im 2))))))))
#s(approx (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 (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (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)) 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 (/ (/ (pow (log base) 4) (log base)) (log base)) #s(hole binary64 (pow (log base) 2)))
#s(approx (/ (pow (log base) 4) (log base)) #s(hole binary64 (pow (log base) 3)))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log base) 4)))
#s(approx (* (log (log base)) 1) #s(hole binary64 (log (log base))))
#s(approx (neg (log base)) #s(hole binary64 (* -1 (log base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) (/ (/ (pow (log base) 4) (log base)) (log base))) #s(hole binary64 (* -1 (/ (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) 0) #s(hole binary64 (* -1 (* (log (sqrt (+ (pow im 2) (pow re 2)))) (log (/ 1 base))))))
#s(approx (log base) #s(hole binary64 (* -1 (log (/ 1 base)))))
#s(approx (/ (/ (pow (log base) 4) (log base)) (log base)) #s(hole binary64 (pow (log (/ 1 base)) 2)))
#s(approx (/ (pow (log base) 4) (log base)) #s(hole binary64 (* -1 (pow (log (/ 1 base)) 3))))
#s(approx (pow (log base) 4) #s(hole binary64 (pow (log (/ 1 base)) 4)))
#s(approx (/ (log (neg im)) (log base)) #s(hole binary64 (* -1 (/ (log (neg im)) (log (/ 1 base))))))
#s(approx (* (log (log base)) 1) #s(hole binary64 (log (* -1 (log (/ 1 base))))))
#s(approx (* (neg (log base)) (log (/ -1 re))) #s(hole binary64 (* (log (/ -1 re)) (log (/ 1 base)))))
#s(approx (neg (log base)) #s(hole binary64 (log (/ 1 base))))
Outputs
(*.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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))))
(/.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (+.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
(/.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) #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 (+.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)) #s(literal 1 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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 (neg.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (neg.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base)))))
(/.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)))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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))))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(log.f64 (pow.f64 base (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64))) (neg.f64 (*.f64 (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 3 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (*.f64 (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)) (+.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 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base))))
(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 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64))) (neg.f64 (*.f64 (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 3 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (*.f64 (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)) (+.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 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base))))
(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))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (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)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (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)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.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))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (neg.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))) (fabs.f64 re))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)
(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)) (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)) 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)) (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)) 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)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (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)) (fabs.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) im)
(hypot.f64 (fabs.f64 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) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(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) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (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) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.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) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.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 (fabs.f64 re))
(hypot.f64 im (neg.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 (fabs.f64 im))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
re
im
(pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))
(pow.f64 (log.f64 base) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(exp.f64 (log.f64 (log.f64 base)))
(+.f64 (/.f64 (+.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (-.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 base))) #s(literal 2 binary64)))
(log.f64 base)
base
#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 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 1 binary64)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base)))))
(/.f64 (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)))))
(/.f64 (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #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))
(-.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)) (log.f64 (log.f64 base))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) base) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (/.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (pow.f64 base (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (log.f64 base)))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))
(*.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 1 binary64))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 #s(literal 1 binary64) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 4 binary64))
(pow.f64 (*.f64 (log.f64 base) (neg.f64 (log.f64 base))) #s(literal 2 binary64))
(pow.f64 (*.f64 (neg.f64 (log.f64 base)) (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 4 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (log.f64 base) #s(literal 4 binary64))
(/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
(/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
(/.f64 (*.f64 (+.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)) #s(literal 0 binary64))) (*.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (*.f64 (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64)) (+.f64 (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))) #s(literal 0 binary64))) (*.f64 (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64)))) (+.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
(exp.f64 (fma.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base))))
#s(literal 4 binary64)
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
(*.f64 (log.f64 (neg.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(*.f64 (/.f64 (log.f64 (neg.f64 im)) (neg.f64 (log.f64 base))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (neg.f64 im)) (neg.f64 (log.f64 base))))
(/.f64 (log.f64 (neg.f64 im)) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (log.f64 (neg.f64 im)) (log.f64 base))
(/.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 base)))
(neg.f64 (/.f64 (log.f64 (neg.f64 im)) (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (neg.f64 im))))
(neg.f64 (neg.f64 (log.f64 (neg.f64 im))))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (log.f64 #s(literal -1 binary64)))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))
(+.f64 (log.f64 im) (log.f64 #s(literal -1 binary64)))
(log.f64 (neg.f64 im))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) im))
(neg.f64 im)
(exp.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)))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (log.f64 base)))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (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)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (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)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.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))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (neg.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))) (fabs.f64 re))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)
(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)) (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)) 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)) (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)) 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)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (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)) (fabs.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) im)
(hypot.f64 (fabs.f64 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) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(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) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (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) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.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) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.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 (fabs.f64 re))
(hypot.f64 im (neg.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 (fabs.f64 im))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (neg.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (neg.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (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 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (*.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 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 im) im))
(-.f64 (*.f64 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 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 (fabs.f64 re) (fabs.f64 re))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 re re)
(pow.f64 (exp.f64 (log.f64 (fabs.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 (neg.f64 re) #s(literal 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))))
(pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))
(pow.f64 (log.f64 base) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(exp.f64 (log.f64 (log.f64 base)))
(+.f64 (/.f64 (+.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 base))) #s(literal 2 binary64)) (/.f64 (-.f64 (log.f64 base) (/.f64 #s(literal 1 binary64) (log.f64 base))) #s(literal 2 binary64)))
(log.f64 base)
(*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 (log.f64 base)))
(log.f64 (log.f64 base))
(*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 (log.f64 base)))
(log.f64 (log.f64 base))
#s(literal 1 binary64)
(*.f64 (/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (log.f64 base))
(*.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (neg.f64 (neg.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))))) (neg.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base)))))
(/.f64 (neg.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re)))))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 base (/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)))))
#s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re)))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))
(*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base)) #s(literal -1 binary64))
(*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 base)))
(*.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base)))
(neg.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 base)))
(log.f64 (pow.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) (log.f64 base)) #s(literal -1 binary64)))
(log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) (neg.f64 (log.f64 base))))
(*.f64 #s(literal -1 binary64) (log.f64 base))
(*.f64 (log.f64 base) #s(literal -1 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 base)))
(neg.f64 (log.f64 base))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 base)))
(-.f64 #s(literal 0 binary64) (log.f64 base))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64)))
(+.f64 #s(literal 0 binary64) (neg.f64 (log.f64 base)))
(log.f64 (/.f64 #s(literal 1 binary64) base))
(*.f64 (log.f64 (neg.f64 re)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 (neg.f64 re)))
(neg.f64 (log.f64 (neg.f64 re)))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 re))
(-.f64 #s(literal 0 binary64) (log.f64 (neg.f64 re)))
(+.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 re)))
(log.f64 (/.f64 #s(literal -1 binary64) re))
(*.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re))
(pow.f64 (neg.f64 re) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (neg.f64 re)))
(/.f64 #s(literal -1 binary64) re)
(/.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (neg.f64 re))
(neg.f64 (/.f64 #s(literal 1 binary64) re))
(exp.f64 (neg.f64 (log.f64 (neg.f64 re))))
#s(literal -1 binary64)
(*.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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))))
(/.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64))) (exp.f64 (*.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)) #s(literal 3 binary64))))
(/.f64 (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (+.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))))))
(/.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) #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 (+.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)) #s(literal 1 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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 (neg.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (neg.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base)))))
(/.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)))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(fma.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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))))
(+.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (log.f64 base) (log.f64 base))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(log.f64 (pow.f64 (pow.f64 base (log.f64 base)) (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 binary64)))))
(log.f64 (pow.f64 base (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)))))
(*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64))) (neg.f64 (*.f64 (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 3 binary64)) #s(literal 0 binary64))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 0 binary64)) (*.f64 (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)) (+.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 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(log.f64 (*.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (log.f64 base))))
(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 (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 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 1 binary64)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base)))))
(/.f64 (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)))))
(/.f64 (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #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))
(-.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)) (log.f64 (log.f64 base))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) base) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (/.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 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))))
(*.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)))
(*.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))))
(*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)))
(*.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)))
(*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (log.f64 base) (log.f64 base))
(pow.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (neg.f64 (log.f64 base)) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64))
(pow.f64 (log.f64 base) #s(literal 2 binary64))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) #s(literal 1 binary64)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 base)))
(/.f64 (neg.f64 (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)))) (neg.f64 (neg.f64 (log.f64 base))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)))) (neg.f64 (neg.f64 (*.f64 (log.f64 base) (log.f64 base)))))
(/.f64 (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)))))
(/.f64 (neg.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (neg.f64 (log.f64 base)))
(/.f64 (neg.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64))) (neg.f64 (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base))
(/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(fma.f64 (fabs.f64 (fabs.f64 (log.f64 base))) (fabs.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (fabs.f64 (log.f64 base))) (neg.f64 (fabs.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) (exp.f64 (log.f64 (neg.f64 (log.f64 base)))) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (log.f64 base)) (fabs.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 (log.f64 base))) (neg.f64 (neg.f64 (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (/.f64 #s(literal 1 binary64) (log.f64 base)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))) #s(literal 0 binary64))
(fma.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #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))
(-.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)) (log.f64 (log.f64 base))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(exp.f64 (-.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64)) (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(+.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 (log.f64 base) (log.f64 base)))
(log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) base) (neg.f64 (log.f64 base))))
(log.f64 (*.f64 (pow.f64 base (log.f64 base)) #s(literal 1 binary64)))
(log.f64 (*.f64 #s(literal 1 binary64) (pow.f64 base (log.f64 base))))
(log.f64 (/.f64 (pow.f64 base (log.f64 base)) #s(literal 1 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 (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)
#s(approx (+ (* im im) (* re re)) (*.f64 im im))
#s(approx (+ (* im im) (* re re)) (fma.f64 im im (*.f64 re re)))
#s(approx (* re re) (*.f64 re re))
#s(approx (* (neg (log base)) (log (/ -1 re))) (*.f64 (log.f64 (neg.f64 re)) (log.f64 base)))
#s(approx (log (/ -1 re)) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (/ -1 re) (/.f64 #s(literal -1 binary64) 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 (+ (* im im) (* re re)) (*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re)))
#s(approx (* (neg (log base)) (log (/ -1 re))) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (/ -1 re)) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (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 (/ -1 re)) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (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 (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) (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 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 (/ (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 (+ (* im im) (* re re)) (*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (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))) (*.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 (/ (/ (pow (log base) 4) (log base)) (log base)) (*.f64 (log.f64 base) (log.f64 base)))
#s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (* (log (log base)) 1) (log.f64 (log.f64 base)))
#s(approx (neg (log base)) (neg.f64 (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (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 (/ (/ (pow (log base) 4) (log base)) (log base)) (*.f64 (log.f64 base) (log.f64 base)))
#s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64)))
#s(approx (pow (log base) 4) (pow.f64 (log.f64 base) #s(literal 4 binary64)))
#s(approx (/ (log (neg im)) (log base)) (/.f64 (log.f64 (neg.f64 im)) (log.f64 base)))
#s(approx (* (log (log base)) 1) (log.f64 (neg.f64 (neg.f64 (log.f64 base)))))
#s(approx (* (neg (log base)) (log (/ -1 re))) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (neg (log base)) (neg.f64 (log.f64 base)))

eval85.0ms (1.6%)

Memory
-9.7MiB live, 174.6MiB allocated; 34ms collecting garbage
Compiler

Compiled 9 246 to 2 732 computations (70.5% saved)

prune60.0ms (1.1%)

Memory
17.5MiB live, 112.3MiB allocated; 20ms collecting garbage
Pruning

48 alts after pruning (44 fresh and 4 done)

PrunedKeptTotal
New72521746
Fresh102333
Picked415
Done033
Total73948787
Accuracy
99.9%
Counts
787 → 48
Alt Table
Click to see full alt table
StatusAccuracyProgram
45.7%
(/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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.3%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (/.f64 #s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base)))
99.0%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
99.2%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
47.6%
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
45.7%
(/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64)) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
45.7%
(/.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)) #s(literal 1 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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))))
0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (log.f64 base) (log.f64 base)))
0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)))
0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))) (log.f64 base)))
0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 #s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base)))
0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
10.7%
(/.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
10.7%
(/.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.1%
(/.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
98.0%
(/.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 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
97.5%
(/.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 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #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))))))
98.1%
(/.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 (log.f64 base) (log.f64 base)))
49.5%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
46.7%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
0.0%
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(approx (* (neg (log base)) (log (/ -1 re))) (*.f64 (log.f64 (neg.f64 re)) (log.f64 base)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
46.7%
(/.f64 #s(approx (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (pow.f64 (*.f64 (neg.f64 (log.f64 im)) (log.f64 base)) #s(literal 2 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))))
46.7%
(/.f64 #s(approx (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (pow.f64 (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base)) #s(literal 2 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))))
45.6%
(*.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)))))
47.4%
(*.f64 (/.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (log.f64 base))
47.4%
(*.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
0.0%
(*.f64 (/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (log.f64 base))
47.4%
(*.f64 (*.f64 (log.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))))
0.0%
(*.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
98.0%
(*.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 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
✓47.6%
#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)))
24.5%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (log.f64 (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)) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (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)))
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)) (exp.f64 (log.f64 (log.f64 base)))))
✓10.7%
#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.3%
#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)))
47.1%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
47.5%
#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 re re (*.f64 im 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)) (* 0 0))) (*.f64 (log.f64 (neg.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 base))))
10.7%
#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.2%
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 base))))
Compiler

Compiled 2 150 to 1 396 computations (35.1% saved)

regimes177.0ms (3.3%)

Memory
-29.8MiB live, 200.0MiB allocated; 130ms collecting garbage
Counts
76 → 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 (log.f64 (neg.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 (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 re re (*.f64 im 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 (neg.f64 im)) (exp.f64 (log.f64 (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 (log.f64 base) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (log.f64 base) (log.f64 base)))
(*.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 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (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))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (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))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(*.f64 (*.f64 (log.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 (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 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (neg.f64 im)) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 #s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(approx (* (neg (log base)) (log (/ -1 re))) (*.f64 (log.f64 (neg.f64 re)) (log.f64 base)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 re)) (log.f64 base))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(*.f64 (/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (log.f64 base))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (/.f64 #s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (/.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (log.f64 base))
(*.f64 (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (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)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 #s(approx (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (pow.f64 (*.f64 (neg.f64 (log.f64 im)) (log.f64 base)) #s(literal 2 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 #s(approx (* (- (pow (* (log base) (log (sqrt (+ (* im im) (* re re))))) 2) 0) 1) (pow.f64 (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base)) #s(literal 2 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 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(*.f64 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (*.f64 (log.f64 base) (log.f64 base)))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (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 (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 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.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 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (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)) #s(literal 1 binary64)) (*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base)))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))) (log.f64 base)))
(/.f64 (*.f64 (pow.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64)) (*.f64 (log.f64 base) (log.f64 base))) (*.f64 (fma.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (/.f64 (-.f64 (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 (pow.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base)) #s(literal 2 binary64)) #s(literal 0 binary64)) (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #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 (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 4 binary64))) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #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))))))
(/.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))) (log.f64 base)) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))) (*.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)) #s(literal 1 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (*.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))))
Outputs
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
Calls

5 calls:

92.0ms
(log.f64 base)
22.0ms
im
22.0ms
re
20.0ms
base
16.0ms
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
Results
AccuracySegmentsBranch
99.3%1(log.f64 base)
99.3%1(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
99.3%1re
99.3%1im
99.3%1base
Compiler

Compiled 27 to 31 computations (-14.8% saved)

regimes120.0ms (2.3%)

Memory
5.5MiB live, 143.8MiB allocated; 15ms collecting garbage
Counts
51 → 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 (log.f64 (neg.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 (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 re re (*.f64 im 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 (neg.f64 im)) (exp.f64 (log.f64 (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 (log.f64 base) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (log.f64 base) (log.f64 base)))
(*.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 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (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))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (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))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(*.f64 (*.f64 (log.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 (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 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (neg.f64 im)) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 #s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(approx (* (neg (log base)) (log (/ -1 re))) (*.f64 (log.f64 (neg.f64 re)) (log.f64 base)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 re)) (log.f64 base))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(*.f64 (/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (log.f64 base))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (/.f64 #s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (/.f64 (*.f64 (log.f64 base) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
(*.f64 (/.f64 (*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 base)) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (log.f64 base))
(*.f64 (/.f64 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (pow.f64 (log.f64 base) #s(literal 4 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (*.f64 (log.f64 base) (log.f64 base)) #s(literal 2 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (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)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
Outputs
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (*.f64 (log.f64 base) (log.f64 base)))
Calls

5 calls:

51.0ms
re
26.0ms
base
14.0ms
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
13.0ms
im
13.0ms
(log.f64 base)
Results
AccuracySegmentsBranch
99.3%1(log.f64 base)
99.3%1(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
99.3%1re
99.3%1im
99.3%1base
Compiler

Compiled 27 to 31 computations (-14.8% saved)

regimes102.0ms (1.9%)

Memory
-7.5MiB live, 133.7MiB allocated; 13ms collecting garbage
Counts
41 → 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 (log.f64 (neg.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 (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 re re (*.f64 im 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 (neg.f64 im)) (exp.f64 (log.f64 (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 (log.f64 base) (log.f64 base)))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 im) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (log.f64 base) (log.f64 base)))
(*.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 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(*.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (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))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (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))) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 1 binary64)))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (log.f64 base)) #s(literal 2 binary64))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(*.f64 (*.f64 (log.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 (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 (fma.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 base) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 base) (log.f64 base))))
#s(approx (/ (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (+ (* (log base) (log base)) (* 0 0))) (/.f64 (log.f64 (neg.f64 im)) (pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (log.f64 base)))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 base))) #s(literal 2 binary64))))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 #s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(approx (* (atan2 im re) 0) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) #s(approx (* (neg (log base)) (log (/ -1 re))) (*.f64 (log.f64 (neg.f64 re)) (log.f64 base)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 re)) (log.f64 base))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 im)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(*.f64 (/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base))) (log.f64 base))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (log.f64 (fabs.f64 im)) (log.f64 base))) (/.f64 (-.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (*.f64 (log.f64 base) (log.f64 base))))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (/.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (log.f64 base)) (log.f64 base)))
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (/.f64 #s(approx (/ (pow (log base) 4) (log base)) (pow.f64 (log.f64 base) #s(literal 3 binary64))) (log.f64 base)))
(/.f64 #s(approx (+ (* (log (sqrt (+ (* re re) (* im im)))) (log base)) (* (atan2 im re) 0)) (*.f64 (neg.f64 (log.f64 base)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (*.f64 (pow.f64 (log.f64 base) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 base))) (log.f64 base)))
Outputs
(/.f64 (+.f64 (*.f64 (log.f64 (hypot.f64 re im)) (log.f64 base)) #s(literal 0 binary64)) (*.f64 (log.f64 base) (log.f64 base)))
Calls

5 calls:

34.0ms
re
34.0ms
base
13.0ms
(log.f64 base)
10.0ms
im
9.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)

regimes56.0ms (1.1%)

Memory
-14.1MiB live, 86.5MiB allocated; 9ms collecting garbage
Accuracy

Total -62.9b remaining (-5657.1%)

Threshold costs -62.9b (-5657.1%)

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

5 calls:

25.0ms
(log.f64 base)
9.0ms
im
7.0ms
re
7.0ms
base
6.0ms
(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
Results
AccuracySegmentsBranch
98.3%1(log.f64 base)
98.3%1(/.f64 (+.f64 (*.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 base)) (*.f64 (atan2.f64 im re) #s(literal 0 binary64))) (+.f64 (*.f64 (log.f64 base) (log.f64 base)) (*.f64 #s(literal 0 binary64) #s(literal 0 binary64))))
98.3%1re
98.3%1im
98.3%1base
Compiler

Compiled 27 to 31 computations (-14.8% saved)

derivations222.0ms (4.2%)

Memory
8.9MiB live, 279.1MiB allocated; 59ms collecting garbage
Stop Event
1×fuel
Compiler

Compiled 56 to 43 computations (23.2% saved)

preprocess115.0ms (2.2%)

Memory
12.9MiB live, 114.4MiB allocated; 42ms collecting garbage
Compiler

Compiled 522 to 451 computations (13.6% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...