math.log10 on complex, real part

Time bar (total: 3.5s)

start0.0ms (0%)

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

analyze55.0ms (1.6%)

Memory
18.6MiB live, 110.8MiB allocated; 12ms 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%99.9%0.1%0%0%0%4
18.8%18.7%81.2%0.1%0%0%0%5
34.4%34.3%65.6%0.1%0%0%0%6
54.7%54.6%45.3%0.1%0%0%0%7
64.8%64.8%35.1%0.1%0%0%0%8
76.2%76.1%23.8%0.1%0%0%0%9
81.8%81.8%18.1%0.1%0%0%0%10
87.8%87.7%12.2%0.1%0%0%0%11
90.8%90.7%9.2%0.1%0%0%0%12
Compiler

Compiled 14 to 9 computations (35.7% saved)

sample951.0ms (27.1%)

Memory
-4.1MiB live, 1 319.2MiB allocated; 381ms collecting garbage
Samples
750.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 426.0ms
ival-hypot: 256.0ms (60.2% of total)
ival-log: 123.0ms (28.9% of total)
ival-div!: 45.0ms (10.6% of total)
adjust: 2.0ms (0.5% of total)
Bogosity

preprocess134.0ms (3.8%)

Memory
-38.1MiB live, 54.4MiB allocated; 13ms collecting garbage
Iterations

Useful iterations: 4 (0.0ms)

IterNodesCost
02874
19272
221572
333972
487666
5586166
Stop Event
1×node-limit
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶52.0%
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 20 to 20 computations (0% saved)

series15.0ms (0.4%)

Memory
29.2MiB live, 29.2MiB allocated; 0ms collecting garbage
Counts
10 → 77
Calls
Call 1
Inputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(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 #s(literal 10 binary64))
#s(literal 10 binary64)
Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 10)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#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 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#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 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#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))))))))))
Calls

6 calls:

TimeVariablePointExpression
3.0ms
im
@0
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)
3.0ms
re
@0
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)
3.0ms
re
@inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)
2.0ms
im
@inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)
1.0ms
re
@-inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)

rewrite176.0ms (5%)

Memory
6.9MiB live, 250.0MiB allocated; 43ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03822692
03922510
127432332
083901877
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
87 → 289
Calls
Call 1
Inputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(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 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 10)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#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 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#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 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#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))))))))))
Outputs
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64))
(/.f64 (neg.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64))) (fabs.f64 re))
(*.f64 (sqrt.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64))) (fabs.f64 im))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (fabs.f64 re))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (fabs.f64 im))
(*.f64 (fabs.f64 re) (sqrt.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64))))
(*.f64 (fabs.f64 re) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (fabs.f64 im) (sqrt.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64))))
(*.f64 (fabs.f64 im) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(sqrt.f64 (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (neg.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 (neg.f64 (neg.f64 re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (neg.f64 (neg.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (neg.f64 (fabs.f64 im)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (neg.f64 im))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 re))) im)
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (neg.f64 (neg.f64 re)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (neg.f64 (fabs.f64 re)))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) (fabs.f64 re))
(hypot.f64 (exp.f64 (log.f64 (fabs.f64 im))) re)
(hypot.f64 (pow.f64 (neg.f64 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 (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 (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 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 (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 (fabs.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 re) (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 (fabs.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (exp.f64 (log.f64 (fabs.f64 re))))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (neg.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im re)
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (exp.f64 (log.f64 (fabs.f64 im))))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im))
(*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re))
(*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (neg.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (neg.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 (fabs.f64 re))) (exp.f64 (log.f64 (fabs.f64 re))) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 (fabs.f64 im))) (exp.f64 (log.f64 (fabs.f64 im))) (*.f64 re re))
(fma.f64 (pow.f64 (neg.f64 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 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 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(fma.f64 #s(literal 1 binary64) (*.f64 im im) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (*.f64 im im) #s(literal 1 binary64) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 im) im))
(-.f64 (*.f64 re re) (neg.f64 (*.f64 im im)))
(-.f64 (*.f64 im im) (neg.f64 (*.f64 re re)))
(+.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(+.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 im im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 re re)) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(+.f64 (*.f64 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 im) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.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))))
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (fabs.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (fabs.f64 im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (/.f64 (log.f64 (fabs.f64 im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (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 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (/.f64 (log.f64 (fabs.f64 im)) (log.f64 #s(literal 10 binary64)))))
#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 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) (log.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (neg.f64 re)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (neg.f64 re)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (neg.f64 re)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (neg.f64 re)) (log.f64 #s(literal 10 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 10)) (/.f64 (log.f64 (fabs.f64 re)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (fabs.f64 re)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (/.f64 (log.f64 (fabs.f64 re)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (/.f64 (log.f64 (fabs.f64 re)) (log.f64 #s(literal 10 binary64)))))
#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 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 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))))

eval35.0ms (1%)

Memory
-17.3MiB live, 75.5MiB allocated; 11ms collecting garbage
Compiler

Compiled 3 076 to 1 173 computations (61.9% saved)

prune9.0ms (0.3%)

Memory
25.9MiB live, 25.9MiB allocated; 0ms collecting garbage
Pruning

8 alts after pruning (8 fresh and 0 done)

PrunedKeptTotal
New2728280
Fresh000
Picked101
Done000
Total2738281
Accuracy
99.4%
Counts
281 → 8
Alt Table
Click to see full alt table
StatusAccuracyProgram
51.9%
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
▶99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶52.0%
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
0.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
▶0.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
11.0%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
▶98.2%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
▶52.0%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
Compiler

Compiled 170 to 170 computations (0% saved)

series78.0ms (2.2%)

Memory
-13.8MiB live, 85.0MiB allocated; 13ms collecting garbage
Counts
26 → 102
Calls
Call 1
Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
re
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
(*.f64 im im)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (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)
Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#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 (+ (* 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 (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow im 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow re 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#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 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#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 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))))
Calls

6 calls:

TimeVariablePointExpression
29.0ms
im
@inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
25.0ms
im
@0
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
10.0ms
im
@-inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
6.0ms
re
@0
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
3.0ms
re
@inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))

rewrite252.0ms (7.2%)

Memory
-3.1MiB live, 271.2MiB allocated; 30ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
06654360
06953909
150693741
082813615
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
128 → 619
Calls
Call 1
Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
re
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
(*.f64 im im)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (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(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#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 (+ (* 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 (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow im 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#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 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log (sqrt (pow re 2)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* 1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log (sqrt (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow (sqrt (pow re 2)) 6))) (* 1/4 (/ 1 (pow (sqrt (pow re 2)) 4))))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (sqrt (pow re 2))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* 1/2 (/ (pow im 2) (sqrt (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow (sqrt (pow re 2)) 3))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ (sqrt (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow (sqrt (pow re 2)) 5))) (* 1/8 (/ 1 (pow (sqrt (pow re 2)) 3))))) (* 1/2 (/ 1 (sqrt (pow re 2)))))))))
#s(approx im #s(hole binary64 im))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow re 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#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 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#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 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))))
Outputs
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 re re)))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 im im)))
(*.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal -1/2 binary64)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.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)))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (sqrt.f64 (*.f64 im 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)))) im)
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (fabs.f64 re))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) re)
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (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 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (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 (fabs.f64 re) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (sqrt.f64 (*.f64 re re)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (sqrt.f64 (*.f64 im im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (fabs.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (neg.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) re)
(hypot.f64 (neg.f64 im) (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 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)
(hypot.f64 re (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 re (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (sqrt.f64 (*.f64 im im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
re
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(*.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1 binary64))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(neg.f64 (neg.f64 (log.f64 im)))
(log.f64 im)
(*.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) #s(literal -1 binary64))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (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)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 re re)))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 im im)))
(*.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal -1/2 binary64)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.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)))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (sqrt.f64 (*.f64 im 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)))) im)
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (fabs.f64 re))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) re)
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (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 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (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 (fabs.f64 re) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (sqrt.f64 (*.f64 re re)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (sqrt.f64 (*.f64 im im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (fabs.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (neg.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) re)
(hypot.f64 (neg.f64 im) (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 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)
(hypot.f64 re (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 re (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (sqrt.f64 (*.f64 im im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im))
(*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re))
(*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (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 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 re re))
(fma.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (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 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)) (*.f64 im im))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(fma.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)) (*.f64 re re))
(fma.f64 (*.f64 im im) #s(literal 1 binary64) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(fma.f64 #s(literal 1 binary64) (*.f64 im im) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(fma.f64 (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 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(+.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 re re)) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 im im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(*.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(*.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 im im)
(pow.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (*.f64 im im)) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 im #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.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 (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64))))
(+.f64 (cosh.f64 (*.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 im) #s(literal 2 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(log.f64 (pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
#s(literal 1 binary64)
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 re re)))
(*.f64 (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 im im)))
(*.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal -1/2 binary64)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.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)))) (fabs.f64 im))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))) (sqrt.f64 (*.f64 im 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)))) im)
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (fabs.f64 re))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (neg.f64 re))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) re)
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (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 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (fabs.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (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 (fabs.f64 re) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (fabs.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (neg.f64 re) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (sqrt.f64 (*.f64 re re)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (fabs.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 im im)))
(hypot.f64 (sqrt.f64 (*.f64 re re)) (neg.f64 im))
(hypot.f64 (sqrt.f64 (*.f64 re re)) im)
(hypot.f64 (sqrt.f64 (*.f64 im im)) (exp.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (fabs.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (fabs.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (neg.f64 re))
(hypot.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 re re)))
(hypot.f64 (sqrt.f64 (*.f64 im im)) re)
(hypot.f64 (neg.f64 im) (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 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)
(hypot.f64 re (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
(hypot.f64 re (pow.f64 (fabs.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (sqrt.f64 (*.f64 im im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im))
(*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re))
(*.f64 (*.f64 re re) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)))
(*.f64 (*.f64 im im) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (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 (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 re re))
(fma.f64 (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (pow.f64 (fabs.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (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 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)) (*.f64 im im))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(fma.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)) (*.f64 re re))
(fma.f64 (*.f64 im im) #s(literal 1 binary64) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(fma.f64 #s(literal 1 binary64) (*.f64 im im) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(fma.f64 (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 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) (/.f64 (*.f64 im im) (*.f64 re re))))
(+.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (*.f64 (*.f64 im im) (/.f64 (*.f64 re re) (*.f64 im im))))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 re re)) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re re)))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 im im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(*.f64 (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)))
(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 (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))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (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 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 im im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.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 (sqrt.f64 (*.f64 im im)))))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) (sqrt.f64 (*.f64 im im))) #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (sqrt.f64 (*.f64 im im)) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))) (*.f64 re re) (sqrt.f64 (*.f64 im im))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) (pow.f64 (*.f64 im im) #s(literal -5/2 binary64))) #s(literal 1/16 binary64)) (/.f64 #s(literal 1/8 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))) (*.f64 re re) (sqrt.f64 (*.f64 im im))))
#s(approx re re)
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (-.f64 (neg.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 im im)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)))))) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im)))) (*.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 im im)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 im im))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 im im)) #s(literal 3 binary64))))) (*.f64 re re))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 im im)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64))))))) (*.f64 re re) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im))))) (*.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (* re re) (*.f64 re re))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) (log.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (exp.f64 (-.f64 (*.f64 (log.f64 im) #s(literal 6 binary64)) (*.f64 (log.f64 re) #s(literal 6 binary64)))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re (neg.f64 (log.f64 re))) (*.f64 re (neg.f64 (log.f64 re))))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal -3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal -1/4 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re (neg.f64 (log.f64 re))) (*.f64 re (neg.f64 (log.f64 re))))) #s(literal 1/2 binary64))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal -3 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal -3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal -1/4 binary64))) (*.f64 im im)) (neg.f64 (log.f64 re))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal 1/720 binary64)))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re (neg.f64 (log.f64 re))) (*.f64 re (neg.f64 (log.f64 re))))) #s(literal 1/2 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (neg.f64 re)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (neg.f64 re)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (neg.f64 re)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (neg.f64 re)) (log.f64 #s(literal 10 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 (exp.f64 (-.f64 (*.f64 (log.f64 im) #s(literal 6 binary64)) (*.f64 (log.f64 re) #s(literal 6 binary64)))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re (neg.f64 (log.f64 (neg.f64 re)))))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re)))) (-.f64 (neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal -1/4 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re (neg.f64 (log.f64 (neg.f64 re)))))) #s(literal 1/2 binary64)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -3 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal -1/4 binary64))) (*.f64 im im))) (log.f64 (neg.f64 re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal 1/720 binary64)))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re (neg.f64 (log.f64 (neg.f64 re)))))) #s(literal 1/2 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (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 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 re re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.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 (+ (* re re) (* im im))) (sqrt.f64 (*.f64 re re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 im im) (sqrt.f64 (*.f64 re re))) #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (sqrt.f64 (*.f64 re re)) (*.f64 re re))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re)))) (*.f64 im im) (sqrt.f64 (*.f64 re re))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (*.f64 (*.f64 (*.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 im im)
#s(approx (log im) (log.f64 im))
#s(approx (neg im) (neg.f64 im))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (-.f64 (neg.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 re re)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re)))) (*.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 re re)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 re re)) #s(literal 3 binary64))))) (*.f64 im im))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 re re)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))) (*.f64 im im) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re))))) (*.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (fma.f64 (exp.f64 (-.f64 (*.f64 (log.f64 re) #s(literal 6 binary64)) (*.f64 (log.f64 im) #s(literal 6 binary64)))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im (neg.f64 (log.f64 im))) (*.f64 im (neg.f64 (log.f64 im))))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal -3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal -1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im (neg.f64 (log.f64 im))) (*.f64 im (neg.f64 (log.f64 im))))) #s(literal 1/2 binary64))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal -3 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal -3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal -1/4 binary64))) (*.f64 re re)) (neg.f64 (log.f64 im))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal 1/720 binary64)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im (neg.f64 (log.f64 im))) (*.f64 im (neg.f64 (log.f64 im))))) #s(literal 1/2 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 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 (exp.f64 (-.f64 (*.f64 (log.f64 re) #s(literal 6 binary64)) (*.f64 (log.f64 im) #s(literal 6 binary64)))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) #s(literal 1 binary64))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im (neg.f64 (log.f64 (neg.f64 im)))))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im)))) (-.f64 (neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal -1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im (neg.f64 (log.f64 (neg.f64 im)))))) #s(literal 1/2 binary64)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -3 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal -1/4 binary64))) (*.f64 re re))) (log.f64 (neg.f64 im))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal 1/720 binary64)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im (neg.f64 (log.f64 (neg.f64 im)))))) #s(literal 1/2 binary64))))))

eval68.0ms (1.9%)

Memory
-20.6MiB live, 83.0MiB allocated; 10ms collecting garbage
Compiler

Compiled 4 502 to 1 494 computations (66.8% saved)

prune11.0ms (0.3%)

Memory
27.6MiB live, 27.6MiB allocated; 0ms collecting garbage
Pruning

16 alts after pruning (12 fresh and 4 done)

PrunedKeptTotal
New3129321
Fresh033
Picked145
Done000
Total31316329
Accuracy
99.9%
Counts
329 → 16
Alt Table
Click to see full alt table
StatusAccuracyProgram
51.9%
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
0.0%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
▶98.2%
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓52.0%
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
0.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
✓0.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
▶11.0%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
✓98.2%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
▶0.0%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
▶98.2%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
6.7%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
0.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))
0.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im))))))
11.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))))
▶98.2%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
Compiler

Compiled 402 to 402 computations (0% saved)

series145.0ms (4.1%)

Memory
-17.6MiB live, 174.0MiB allocated; 30ms collecting garbage
Counts
25 → 149
Calls
Call 1
Inputs
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
(log.f64 re)
re
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(neg.f64 (log.f64 im))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
Outputs
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow im 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#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 (log re) #s(hole binary64 (log re)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow im 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (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))))) (log (sqrt (pow im 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 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (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/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 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (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)))
#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 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow re 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#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 (log im) #s(hole binary64 (log im)))
#s(approx im #s(hole binary64 im))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow re 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (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))))) (log (sqrt (pow re 2))))))
#s(approx (/ (log 1/10) (neg (log im))) #s(hole binary64 (* -1 (/ (log 1/10) (log im)))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (log im))))
#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 (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (log 1/10) (neg (log im))) #s(hole binary64 (/ (log 1/10) (log (/ 1 im)))))
#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 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (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/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))))))))))
Calls

6 calls:

TimeVariablePointExpression
35.0ms
im
@-inf
((/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (log 1/10) (neg (log im))) (neg (log im)) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im))
31.0ms
im
@0
((/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (log 1/10) (neg (log im))) (neg (log im)) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im))
30.0ms
im
@inf
((/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (log 1/10) (neg (log im))) (neg (log im)) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im))
22.0ms
re
@0
((/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (log 1/10) (neg (log im))) (neg (log im)) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im))
15.0ms
re
@inf
((/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (log 1/10) (neg (log im))) (neg (log im)) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im))

rewrite235.0ms (6.7%)

Memory
32.9MiB live, 303.8MiB allocated; 42ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
08536743
08776228
165336020
092825090
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
174 → 242
Calls
Call 1
Inputs
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
(log.f64 re)
re
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(neg.f64 (log.f64 im))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(neg.f64 im)
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow im 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#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 (log re) #s(hole binary64 (log re)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow im 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (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))))) (log (sqrt (pow im 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 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (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/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 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (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)))
#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 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow re 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#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 (log im) #s(hole binary64 (log im)))
#s(approx im #s(hole binary64 im))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow re 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (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))))) (log (sqrt (pow re 2))))))
#s(approx (/ (log 1/10) (neg (log im))) #s(hole binary64 (* -1 (/ (log 1/10) (log im)))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (log im))))
#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 (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (log 1/10) (neg (log im))) #s(hole binary64 (/ (log 1/10) (log (/ 1 im)))))
#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 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (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/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))))))))))
Outputs
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(*.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1 binary64))
(/.f64 (neg.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(neg.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64)))
#s(literal 1 binary64)
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(*.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
(log.f64 re)
re
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(*.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1 binary64))
(/.f64 (neg.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(neg.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64)))
(neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(pow.f64 #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(exp.f64 (*.f64 (log.f64 #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal -1 binary64)))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (neg.f64 (log.f64 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(*.f64 (log.f64 im) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 im))
(neg.f64 (log.f64 (/.f64 im #s(literal 1 binary64))))
(neg.f64 (log.f64 im))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 im #s(literal 1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 im))
(+.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im)))
(log.f64 (/.f64 #s(literal 1 binary64) im))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))) #s(literal -1 binary64)))
(log.f64 (pow.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(neg.f64 im)
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (-.f64 (neg.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)))))) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im)))) (*.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 im im))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 im #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (*.f64 re re))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64))))))) (*.f64 re re) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (*.f64 im im))))) (*.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 im im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (log re) (log.f64 re))
#s(approx re re)
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64)) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im)))) (*.f64 re re) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (-.f64 (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))))) (*.f64 re re)) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im)))) (*.f64 re re) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/4 binary64)) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re)) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.f64 (-.f64 (*.f64 (fma.f64 #s(literal -1/6 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re re)) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re)) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) (sqrt.f64 (*.f64 im im))) #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (sqrt.f64 (*.f64 im im)) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))) (*.f64 re re) (sqrt.f64 (*.f64 im im))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 re re)) (pow.f64 (*.f64 im im) #s(literal 5/2 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))) (*.f64 re re) (sqrt.f64 (*.f64 im im))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (*.f64 (*.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 re re)))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal -1/4 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))) (*.f64 (*.f64 (*.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 re re)))) #s(literal 1/2 binary64))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal -1/4 binary64))) (*.f64 im im)) (neg.f64 (log.f64 re))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) #s(literal 1/720 binary64)))) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 (*.f64 re re) (*.f64 re re))))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))) #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re))) (*.f64 re re)))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 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 #s(literal 1/10 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 re)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal 1/4 binary64) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (neg.f64 (neg.f64 (log.f64 re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal -1/4 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re re))) #s(literal 1/2 binary64))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal -1/4 binary64))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) #s(literal 1/720 binary64)))) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))) (*.f64 re re))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 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 #s(literal 1/10 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.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) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (-.f64 (neg.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re)))) (*.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 re #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (*.f64 im im))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))) (*.f64 im im) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (*.f64 re re))))) (*.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 re re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (log im) (log.f64 im))
#s(approx im im)
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re)))) (*.f64 im im) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (-.f64 (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))))) (*.f64 im im)) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re)))) (*.f64 im im) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.f64 (-.f64 (*.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 (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.f64 (-.f64 (*.f64 (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) #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 (/ (log 1/10) (neg (log im))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
#s(approx (neg (log im)) (neg.f64 (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 re re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 im im) (sqrt.f64 (*.f64 re re))) #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (sqrt.f64 (*.f64 re re)) (*.f64 re re))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re)))) (*.f64 im im) (sqrt.f64 (*.f64 re re))))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 im im)) (pow.f64 (*.f64 re re) #s(literal 5/2 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (sqrt.f64 (*.f64 re re)) (*.f64 re re)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re)))) (*.f64 im im) (sqrt.f64 (*.f64 re re))))
#s(approx (neg im) (neg.f64 im))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 im im)))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal -1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (*.f64 (*.f64 (*.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 im im)))) #s(literal 1/2 binary64))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal -1/4 binary64))) (*.f64 re re)) (neg.f64 (log.f64 im))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) #s(literal 1/720 binary64)))) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 (*.f64 im im) (*.f64 im im))))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))) #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im))) (*.f64 im im)))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (neg.f64 (neg.f64 (log.f64 im)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im 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 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (neg.f64 (neg.f64 (log.f64 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (neg.f64 (neg.f64 (log.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 1/10) (neg (log im))) (/.f64 (log.f64 #s(literal 10 binary64)) (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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #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 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal -1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im))))) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im im))) #s(literal 1/2 binary64))))
#s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (-.f64 (+.f64 (neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal -1/4 binary64))) (neg.f64 (log.f64 (neg.f64 im))))) (*.f64 (/.f64 (*.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))) #s(literal 1/720 binary64)))) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal 3 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 im))) (neg.f64 (log.f64 (neg.f64 im)))) (*.f64 im im))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.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 re re) (*.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))))
#s(approx (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))))

eval21.0ms (0.6%)

Memory
15.4MiB live, 60.5MiB allocated; 5ms collecting garbage
Compiler

Compiled 4 792 to 1 079 computations (77.5% saved)

prune17.0ms (0.5%)

Memory
-9.3MiB live, 46.0MiB allocated; 13ms collecting garbage
Pruning

21 alts after pruning (12 fresh and 9 done)

PrunedKeptTotal
New2207227
Fresh257
Picked055
Done044
Total22221243
Accuracy
99.9%
Counts
243 → 21
Alt Table
Click to see full alt table
StatusAccuracyProgram
51.9%
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
0.0%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
11.0%
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))) (log.f64 #s(literal 1/10 binary64)))
✓98.2%
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓52.0%
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
▶0.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
✓0.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
▶0.0%
(/.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
✓11.0%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
✓98.2%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
0.0%
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
▶0.0%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
✓0.0%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
▶11.0%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
✓98.2%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
0.0%
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))))
0.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))
11.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))))
✓98.2%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
▶71.9%
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64)))
Compiler

Compiled 459 to 459 computations (0% saved)

series166.0ms (4.7%)

Memory
1.7MiB live, 328.2MiB allocated; 24ms collecting garbage
Counts
28 → 198
Calls
Call 1
Inputs
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64)))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
#s(literal -1 binary64)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
re
(/.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))
(neg.f64 (log.f64 (neg.f64 re)))
(log.f64 (neg.f64 re))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
(log.f64 re)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))))
Outputs
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (/ (log 10) (log (sqrt (pow im 2))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow im 2)))))) (* 1/2 (/ (pow re 2) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow im 2)))))) (* (pow re 2) (+ (* -1/24 (* (pow re 2) (- (* -24 (/ (* (log (sqrt (pow im 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ 1 (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow im 2)))))) (* (pow re 2) (+ (* (pow re 2) (+ (* -1/24 (- (* -24 (/ (* (log (sqrt (pow im 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))))) (* -1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log (sqrt (pow im 2))) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6))))))) (log 10))) (* -360 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log 10) (pow (sqrt (pow im 2)) 2))))) (* 30 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6))))))))) (* 1/2 (/ 1 (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow im 2))))) (* -1/2 (/ (pow re 2) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow im 2))))) (* (pow re 2) (- (* 1/24 (* (pow re 2) (- (* -24 (/ (* (log (sqrt (pow im 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ 1 (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow im 2))))) (* (pow re 2) (- (* (pow re 2) (+ (* 1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log (sqrt (pow im 2))) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6))))))) (log 10))) (* -360 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log 10) (pow (sqrt (pow im 2)) 2))))) (* 30 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6))))))) (* 1/24 (- (* -24 (/ (* (log (sqrt (pow im 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))))))) (* 1/2 (/ 1 (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow im 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#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 (neg re) #s(hole binary64 (* -1 re)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow im 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (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))))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (neg re))) #s(hole binary64 (* -1 (log (neg re)))))
#s(approx (log (neg re)) #s(hole binary64 (log (neg re))))
#s(approx (log re) #s(hole binary64 (log re)))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (* -1 (/ (log 10) (log (/ 1 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10)))) (pow re 4)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re))))))) (log 10))))) (pow re 6))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (* -1 (/ (log 10) (log (/ 1 re)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (neg (log (neg re))) #s(hole binary64 (log (neg (/ 1 re)))))
#s(approx (log (neg re)) #s(hole binary64 (* -1 (log (neg (/ 1 re))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (* -1 (/ (log 10) (log (/ -1 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10)))) (pow re 4)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re))))))) (log 10))))) (pow re 6))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (* -1 (/ (log 10) (log (/ -1 re)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (/ (log 10) (log (sqrt (pow re 2))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow re 2)))))) (* 1/2 (/ (pow im 2) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow re 2)))))) (* (pow im 2) (+ (* -1/24 (* (pow im 2) (- (* -24 (/ (* (log (sqrt (pow re 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ 1 (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow re 2)))))) (* (pow im 2) (+ (* (pow im 2) (+ (* -1/24 (- (* -24 (/ (* (log (sqrt (pow re 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))))) (* -1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log (sqrt (pow re 2))) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6))))))) (log 10))) (* -360 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log 10) (pow (sqrt (pow re 2)) 2))))) (* 30 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6))))))))) (* 1/2 (/ 1 (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow re 2))))) (* -1/2 (/ (pow im 2) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow re 2))))) (* (pow im 2) (- (* 1/24 (* (pow im 2) (- (* -24 (/ (* (log (sqrt (pow re 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ 1 (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow re 2))))) (* (pow im 2) (- (* (pow im 2) (+ (* 1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log (sqrt (pow re 2))) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6))))))) (log 10))) (* -360 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log 10) (pow (sqrt (pow re 2)) 2))))) (* 30 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6))))))) (* 1/24 (- (* -24 (/ (* (log (sqrt (pow re 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))))))) (* 1/2 (/ 1 (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow re 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#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 (log im) #s(hole binary64 (log im)))
#s(approx im #s(hole binary64 im))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow re 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (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))))) (log (sqrt (pow re 2))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10)))) (pow im 4)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im))))))) (log 10))))) (pow im 6))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (* -1 (/ (log 10) (log (/ 1 im)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (* -1 (/ (log 10) (log (/ -1 im))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10)))) (pow im 4)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im))))))) (log 10))))) (pow im 6))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (* -1 (/ (log 10) (log (/ -1 im)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
Calls

6 calls:

TimeVariablePointExpression
64.0ms
re
@inf
((exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im -1 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (neg (log (neg re))) (log (neg re)) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log re) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))))
34.0ms
re
@0
((exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im -1 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (neg (log (neg re))) (log (neg re)) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log re) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))))
20.0ms
re
@-inf
((exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im -1 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (neg (log (neg re))) (log (neg re)) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log re) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))))
16.0ms
im
@inf
((exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im -1 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (neg (log (neg re))) (log (neg re)) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log re) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))))
13.0ms
im
@-inf
((exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) 10 (log (sqrt (+ (* re re) (* im im)))) (log im) im -1 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) re (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (neg (log (neg re))) (log (neg re)) (log 1/10) 1/10 (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log re) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))))

rewrite689.0ms (19.6%)

Memory
-122.8MiB live, 452.7MiB allocated; 940ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0115812200
0118611344
0825610070
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
226 → 270
Calls
Call 1
Inputs
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64)))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
#s(literal -1 binary64)
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
re
(/.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))
(neg.f64 (log.f64 (neg.f64 re)))
(log.f64 (neg.f64 re))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
(log.f64 re)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (/ (log (sqrt (pow im 2))) (log 10))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 2)))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (log 10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow im 2)) 2)))))) (/ (log (sqrt (pow im 2))) (log 10)))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (/ (log 10) (log (sqrt (pow im 2))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow im 2)))))) (* 1/2 (/ (pow re 2) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow im 2)))))) (* (pow re 2) (+ (* -1/24 (* (pow re 2) (- (* -24 (/ (* (log (sqrt (pow im 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ 1 (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow im 2)))))) (* (pow re 2) (+ (* (pow re 2) (+ (* -1/24 (- (* -24 (/ (* (log (sqrt (pow im 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))))) (* -1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log (sqrt (pow im 2))) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6))))))) (log 10))) (* -360 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log 10) (pow (sqrt (pow im 2)) 2))))) (* 30 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6))))))))) (* 1/2 (/ 1 (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow im 2))))) (* -1/2 (/ (pow re 2) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow im 2))))) (* (pow re 2) (- (* 1/24 (* (pow re 2) (- (* -24 (/ (* (log (sqrt (pow im 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ 1 (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow im 2))))) (* (pow re 2) (- (* (pow re 2) (+ (* 1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log (sqrt (pow im 2))) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6))))))) (log 10))) (* -360 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log 10) (pow (sqrt (pow im 2)) 2))))) (* 30 (/ 1 (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6))))))) (* 1/24 (- (* -24 (/ (* (log (sqrt (pow im 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))))))) (* 1/2 (/ 1 (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow im 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))) (* (log (sqrt (pow im 2))) (pow (sqrt (pow im 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 3) (pow (sqrt (pow im 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow im 2))) 2) (pow (sqrt (pow im 2)) 2)))))) (/ (log 10) (log (sqrt (pow im 2)))))))
#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 (neg re) #s(hole binary64 (* -1 re)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow im 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow im 2))) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (log 1/10) (pow (sqrt (pow im 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow im 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow (sqrt (pow im 2)) 2))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow (sqrt (pow im 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow im 2)) 2))))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (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))))) (log (sqrt (pow im 2))))))
#s(approx (neg (log (neg re))) #s(hole binary64 (* -1 (log (neg re)))))
#s(approx (log (neg re)) #s(hole binary64 (log (neg re))))
#s(approx (log re) #s(hole binary64 (log re)))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (* -1 (/ (log 10) (log (/ 1 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10)))) (pow re 4)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re))))))) (log 10))))) (pow re 6))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (* -1 (/ (log 10) (log (/ 1 re)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (neg (log (neg re))) #s(hole binary64 (log (neg (/ 1 re)))))
#s(approx (log (neg re)) #s(hole binary64 (* -1 (log (neg (/ 1 re))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (* -1 (/ (log 10) (log (/ -1 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10)))) (pow re 4)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re))))))) (log 10))))) (pow re 6))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (* -1 (/ (log 10) (log (/ -1 re)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (/ (log (sqrt (pow re 2))) (log 10))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 2)))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (log 10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 10) (pow (sqrt (pow re 2)) 2)))))) (/ (log (sqrt (pow re 2))) (log 10)))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (/ (log 10) (log (sqrt (pow re 2))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow re 2)))))) (* 1/2 (/ (pow im 2) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow re 2)))))) (* (pow im 2) (+ (* -1/24 (* (pow im 2) (- (* -24 (/ (* (log (sqrt (pow re 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ 1 (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (/ (log 10) (log (sqrt (pow re 2)))))) (* (pow im 2) (+ (* (pow im 2) (+ (* -1/24 (- (* -24 (/ (* (log (sqrt (pow re 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))))) (* -1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log (sqrt (pow re 2))) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6))))))) (log 10))) (* -360 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log 10) (pow (sqrt (pow re 2)) 2))))) (* 30 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6))))))))) (* 1/2 (/ 1 (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow re 2))))) (* -1/2 (/ (pow im 2) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow re 2))))) (* (pow im 2) (- (* 1/24 (* (pow im 2) (- (* -24 (/ (* (log (sqrt (pow re 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ 1 (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (/ (log 10) (log (sqrt (pow re 2))))) (* (pow im 2) (- (* (pow im 2) (+ (* 1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log (sqrt (pow re 2))) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6))))))) (log 10))) (* -360 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log 10) (pow (sqrt (pow re 2)) 2))))) (* 30 (/ 1 (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6))))))) (* 1/24 (- (* -24 (/ (* (log (sqrt (pow re 2))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4)))))) (log 10))) (* 3 (/ 1 (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))))))) (* 1/2 (/ 1 (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (/ (log 10) (log (sqrt (pow re 2))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))) (* (log (sqrt (pow re 2))) (pow (sqrt (pow re 2)) 2)))) (+ (* 1/8 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 6)))) (* 1/6 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 6)))))))) (+ (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 4)))) (* -1/4 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 3) (pow (sqrt (pow re 2)) 4))))))) (* 1/2 (/ (log 10) (* (pow (log (sqrt (pow re 2))) 2) (pow (sqrt (pow re 2)) 2)))))) (/ (log 10) (log (sqrt (pow re 2)))))))
#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 (log im) #s(hole binary64 (log im)))
#s(approx im #s(hole binary64 im))
#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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log (sqrt (pow re 2))) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 4)))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log (sqrt (pow re 2))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (log 1/10) (pow (sqrt (pow re 2)) 6)))) (* 1/4 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 4)))))) (* 1/2 (/ 1 (* (log 1/10) (pow (sqrt (pow re 2)) 2)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow (sqrt (pow re 2)) 2))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow (sqrt (pow re 2)) 4))) (* 1/2 (/ 1 (pow (sqrt (pow re 2)) 2))))) (log (sqrt (pow re 2))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* (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))))) (log (sqrt (pow re 2))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10)))) (pow im 4)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im))))))) (log 10))))) (pow im 6))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (* -1 (/ (log 10) (log (/ 1 im)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ 1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (* -1 (log (* -1 (/ (log 10) (log (/ -1 im))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10)))) (pow im 4)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) #s(hole binary64 (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im))))))) (log 10))))) (pow im 6))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (log (* -1 (/ (log 10) (log (/ -1 im)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) #s(hole binary64 (+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (* -1 (/ (log 10) (log (/ -1 im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 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 (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
Outputs
(pow.f64 (exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1 binary64))
(fabs.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64))) (sinh.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64))))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64))
(-.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
#s(literal -1 binary64)
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) #s(literal -1 binary64))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) (neg.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))))))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(*.f64 #s(literal -1 binary64) re)
(neg.f64 re)
re
(*.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))))
(/.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))
(*.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))
(log.f64 (pow.f64 (neg.f64 re) #s(literal -1 binary64)))
(log.f64 (/.f64 #s(literal -1 binary64) re))
(log.f64 (neg.f64 re))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)))
(*.f64 #s(literal 1 binary64) (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))) #s(literal -1 binary64))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)))))
#s(literal 1 binary64)
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
(/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
(log.f64 re)
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) #s(literal -1 binary64))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) (neg.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
(/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))) (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (-.f64 (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im)))))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im)))))) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/24 binary64) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -24 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 3 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im)))))) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/24 binary64) (-.f64 (*.f64 #s(literal -24 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 3 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))) (*.f64 #s(literal -1/720 binary64) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -720 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))) (fma.f64 #s(literal 1/8 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))))) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -360 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))))) (/.f64 #s(literal 30 binary64) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (-.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/24 binary64) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -24 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 3 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))) (*.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/720 binary64) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -720 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))) (fma.f64 #s(literal 1/8 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))))) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -360 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))))) (/.f64 #s(literal 30 binary64) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))))) (*.f64 #s(literal 1/24 binary64) (-.f64 (*.f64 #s(literal -24 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 3 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (fma.f64 (*.f64 re re) (-.f64 (neg.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (neg.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))) (fma.f64 #s(literal 1/8 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))))))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 (sqrt.f64 (*.f64 im im)))) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (sqrt.f64 (*.f64 im im))) #s(literal 2 binary64))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 im im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 im im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (-.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 re re) (pow.f64 (*.f64 im im) #s(literal 2 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 re re)) (pow.f64 (*.f64 im im) #s(literal 3 binary64))) (/.f64 #s(literal 1/4 binary64) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))))))
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (-.f64 (sqrt.f64 (*.f64 im im)) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (sqrt.f64 (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (sqrt.f64 (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) (pow.f64 (*.f64 im im) #s(literal 3/2 binary64))) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (sqrt.f64 (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 re re)) (pow.f64 (*.f64 im im) #s(literal 5/2 binary64))) (/.f64 #s(literal 1/8 binary64) (pow.f64 (*.f64 im im) #s(literal 3/2 binary64)))) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im im)))))))
#s(approx (neg re) (neg.f64 re))
#s(approx re re)
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg.f64 (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (-.f64 (neg.f64 (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (neg.f64 (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 re re)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (neg.f64 (/.f64 (log.f64 (sqrt.f64 (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/6 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (*.f64 im im) #s(literal 3 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (*.f64 im im) #s(literal 2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 re re)) (pow.f64 (*.f64 im im) #s(literal 2 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/6 binary64) (/.f64 (*.f64 re re) (pow.f64 (*.f64 im im) #s(literal 3 binary64))) (/.f64 #s(literal 1/4 binary64) (pow.f64 (*.f64 im im) #s(literal 2 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (*.f64 im im)))))) (log.f64 (sqrt.f64 (*.f64 im im)))))
#s(approx (neg (log (neg re))) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (log (neg re)) (log.f64 (neg.f64 re)))
#s(approx (log re) (log.f64 re))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (/.f64 (neg.f64 (neg.f64 (log.f64 re))) (log.f64 #s(literal 10 binary64))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 re))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (+.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 re))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (+.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 re))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (-.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 re)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 re)))) (*.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal -1/720 binary64) (/.f64 (fma.f64 #s(literal -360 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 30 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) (*.f64 #s(literal 720 binary64) (*.f64 (neg.f64 (log.f64 re)) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))) (neg.f64 (log.f64 re))))))) (log.f64 #s(literal 10 binary64))))))) (pow.f64 re #s(literal 6 binary64))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (-.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 re)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 re))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -360 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 30 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) (*.f64 #s(literal 720 binary64) (*.f64 (neg.f64 (log.f64 re)) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))) (neg.f64 (log.f64 re))))))) (log.f64 #s(literal 10 binary64))))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 re)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (+.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (neg.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))) (*.f64 (*.f64 re re) (*.f64 re re))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (+.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (neg.f64 (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64)))) (neg.f64 (log.f64 re))))))) (pow.f64 re #s(literal 6 binary64))))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 re)) (neg.f64 (log.f64 re)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (-.f64 (neg.f64 (neg.f64 (log.f64 re))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 re (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 re (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 re (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal -1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 re)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (+.f64 (neg.f64 (neg.f64 (log.f64 re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (neg (log (neg re))) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (log (neg re)) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (-.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (-.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 (neg.f64 re))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 (neg.f64 re))))) (fma.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal -1/720 binary64) (/.f64 (fma.f64 #s(literal -360 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 30 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) (*.f64 #s(literal 720 binary64) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)))) (neg.f64 (log.f64 (neg.f64 re)))))))) (log.f64 #s(literal 10 binary64))))))) (pow.f64 re #s(literal 6 binary64))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (-.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re)))))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 (neg.f64 re))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re)))))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 (neg.f64 re)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re)))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -360 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 30 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) (*.f64 #s(literal 720 binary64) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)))) (neg.f64 (log.f64 (neg.f64 re)))))))) (log.f64 #s(literal 10 binary64))))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (neg.f64 (log.f64 (neg.f64 re))))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (+.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))) (neg.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)))) (*.f64 (*.f64 re re) (*.f64 re re))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (+.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))) (neg.f64 (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)))) (neg.f64 (log.f64 (neg.f64 re)))))))) (pow.f64 re #s(literal 6 binary64))))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re)))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (pow.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 re re) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) (neg.f64 (log.f64 (neg.f64 re))))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (-.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (*.f64 re (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (*.f64 re (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (*.f64 re (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal -1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))) (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (-.f64 (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re)))))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re)))))) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/24 binary64) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -24 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 3 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re)))))) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/24 binary64) (-.f64 (*.f64 #s(literal -24 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 3 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64))))) (*.f64 #s(literal -1/720 binary64) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -720 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))) (fma.f64 #s(literal 1/8 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))))) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -360 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))))) (/.f64 #s(literal 30 binary64) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (-.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/24 binary64) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -24 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 3 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64))))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))) (*.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/720 binary64) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -720 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))) (fma.f64 #s(literal 1/8 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))))) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -360 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))))) (/.f64 #s(literal 30 binary64) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))))) (*.f64 #s(literal 1/24 binary64) (-.f64 (*.f64 #s(literal -24 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 3 binary64) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (sqrt.f64 (*.f64 re re))) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (fma.f64 (*.f64 im im) (-.f64 (neg.f64 (*.f64 (*.f64 im im) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (sqrt.f64 (*.f64 re re))) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (neg.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))) (fma.f64 #s(literal 1/8 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))))))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 (sqrt.f64 (*.f64 re re)))) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 (log.f64 (sqrt.f64 (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64))))))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (sqrt.f64 (*.f64 re re))) #s(literal 2 binary64))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 (sqrt.f64 (*.f64 re re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (-.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 im im) (pow.f64 (*.f64 re re) #s(literal 2 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.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 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))))))
#s(approx (log im) (log.f64 im))
#s(approx im im)
#s(approx (sqrt (+ (* re re) (* im im))) (sqrt.f64 (*.f64 re re)))
#s(approx (sqrt (+ (* re re) (* im im))) (-.f64 (sqrt.f64 (*.f64 re re)) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (sqrt.f64 (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (sqrt.f64 (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im im) (pow.f64 (*.f64 re re) #s(literal 3/2 binary64))) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (+.f64 (sqrt.f64 (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.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 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re re)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg.f64 (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (-.f64 (neg.f64 (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 1/10 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (neg.f64 (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (+.f64 (neg.f64 (/.f64 (log.f64 (sqrt.f64 (*.f64 re re))) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/6 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (*.f64 re re) #s(literal 3 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (*.f64 re re) #s(literal 2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (pow.f64 (*.f64 re re) #s(literal 2 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/6 binary64) (/.f64 (*.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 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 re re)) (sqrt.f64 (*.f64 re re)))))) (log.f64 (sqrt.f64 (*.f64 re re)))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (/.f64 (neg.f64 (neg.f64 (log.f64 im))) (log.f64 #s(literal 10 binary64))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (-.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 im))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (+.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 im))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (+.f64 (/.f64 (neg.f64 (neg.f64 (log.f64 im))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (-.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (neg.f64 (log.f64 im)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (neg.f64 (log.f64 im)))) (*.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 im im) (*.f64 im im)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal -1/720 binary64) (/.f64 (fma.f64 #s(literal -360 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 30 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (*.f64 #s(literal 720 binary64) (*.f64 (neg.f64 (log.f64 im)) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (neg.f64 (log.f64 im))))))) (log.f64 #s(literal 10 binary64))))))) (pow.f64 im #s(literal 6 binary64))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (-.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (neg.f64 (log.f64 im)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (neg.f64 (log.f64 im))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -360 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 30 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (*.f64 #s(literal 720 binary64) (*.f64 (neg.f64 (log.f64 im)) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (neg.f64 (log.f64 im))))))) (log.f64 #s(literal 10 binary64))))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 24 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (neg.f64 (log.f64 im)))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (+.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (neg.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (+.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (neg.f64 (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (neg.f64 (log.f64 im))))))) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (*.f64 (neg.f64 (log.f64 im)) (neg.f64 (log.f64 im)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (-.f64 (neg.f64 (neg.f64 (log.f64 im))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 im (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal -1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (neg.f64 (neg.f64 (log.f64 im)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (neg.f64 (neg.f64 (log.f64 im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (+.f64 (neg.f64 (neg.f64 (log.f64 im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (-.f64 (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (+.f64 (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (exp (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1)) (+.f64 (/.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (-.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 24 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))))) (*.f64 (*.f64 im im) (*.f64 im im)))))))
#s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (+.f64 (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 24 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal -1/720 binary64) (/.f64 (fma.f64 #s(literal -360 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 30 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (*.f64 #s(literal 720 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (log.f64 #s(literal 10 binary64))))))) (pow.f64 im #s(literal 6 binary64))))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (-.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 24 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))))) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))
#s(approx (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (+.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -360 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 30 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (*.f64 #s(literal 720 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (log.f64 #s(literal 10 binary64))))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -3 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 24 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 #s(literal 10 binary64)))))) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) im))))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (+.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (neg.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))
#s(approx (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (-.f64 (+.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (neg.f64 (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))))
#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)))) (-.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.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 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.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 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.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))) (neg.f64 (*.f64 im (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 (*.f64 im (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal -1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (+.f64 (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))))))

eval43.0ms (1.2%)

Memory
25.7MiB live, 106.8MiB allocated; 27ms collecting garbage
Compiler

Compiled 8 403 to 1 494 computations (82.2% saved)

prune33.0ms (1%)

Memory
-0.0MiB live, 53.1MiB allocated; 34ms collecting garbage
Pruning

21 alts after pruning (8 fresh and 13 done)

PrunedKeptTotal
New2542256
Fresh167
Picked145
Done099
Total25621277
Accuracy
99.9%
Counts
277 → 21
Alt Table
Click to see full alt table
StatusAccuracyProgram
51.9%
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
0.0%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
11.0%
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))) (log.f64 #s(literal 1/10 binary64)))
✓98.2%
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓52.0%
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓0.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
✓0.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
✓0.0%
(/.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
✓11.0%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
✓98.2%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
0.0%
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
✓0.0%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
✓0.0%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
✓11.0%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
✓98.2%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
0.0%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))))
0.0%
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))))
11.0%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))))
✓98.2%
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
71.9%
(exp.f64 #s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))))))
Compiler

Compiled 566 to 404 computations (28.6% saved)

regimes149.0ms (4.3%)

Memory
-31.1MiB live, 175.1MiB allocated; 99ms collecting garbage
Counts
27 → 1
Calls
Call 1
Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(exp.f64 #s(approx (* (log (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) -1) (neg.f64 (log.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64)))
Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
Calls

8 calls:

74.0ms
(*.f64 im im)
27.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
10.0ms
im
9.0ms
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
7.0ms
re
Results
AccuracySegmentsBranch
99.1%1(*.f64 im im)
99.1%1(*.f64 re re)
99.1%1(+.f64 (*.f64 re re) (*.f64 im im))
99.1%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
99.1%1(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
99.1%1(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
99.1%1re
99.1%1im
Compiler

Compiled 34 to 38 computations (-11.8% saved)

regimes80.0ms (2.3%)

Memory
1.6MiB live, 94.7MiB allocated; 17ms collecting garbage
Counts
23 → 1
Calls
Call 1
Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (neg.f64 re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))))
(/.f64 #s(literal 1 binary64) #s(approx (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (*.f64 re re))))))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
Outputs
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
Calls

8 calls:

34.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
6.0ms
im
6.0ms
re
6.0ms
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
6.0ms
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
Results
AccuracySegmentsBranch
98.2%1(*.f64 im im)
98.2%1(*.f64 re re)
98.2%1(+.f64 (*.f64 re re) (*.f64 im im))
98.2%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
98.2%1(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
98.2%1(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
98.2%1re
98.2%1im
Compiler

Compiled 34 to 38 computations (-11.8% saved)

regimes24.0ms (0.7%)

Memory
15.7MiB live, 61.3MiB allocated; 5ms collecting garbage
Accuracy

Total -62.9b remaining (-5518.7%)

Threshold costs -62.9b (-5518.7%)

Counts
8 → 1
Calls
Call 1
Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (neg (log (sqrt (+ (* re re) (* im im))))) (neg.f64 (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
Outputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
Calls

8 calls:

6.0ms
(*.f64 re re)
3.0ms
im
3.0ms
re
2.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
2.0ms
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
Results
AccuracySegmentsBranch
98.2%1(*.f64 im im)
98.2%1(*.f64 re re)
98.2%1(+.f64 (*.f64 re re) (*.f64 im im))
98.2%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
98.2%1(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
98.2%1(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
98.2%1re
98.2%1im
Compiler

Compiled 34 to 38 computations (-11.8% saved)

derivations80.0ms (2.3%)

Memory
-5.4MiB live, 83.5MiB allocated; 30ms collecting garbage
Stop Event
1×fuel
Compiler

Compiled 26 to 18 computations (30.8% saved)

preprocess41.0ms (1.2%)

Memory
22.5MiB live, 113.0MiB allocated; 10ms collecting garbage
Compiler

Compiled 234 to 226 computations (3.4% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...