math.log10 on complex, real part

Time bar (total: 3.4s)

start0.0ms (0%)

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

analyze78.0ms (2.3%)

Memory
5.9MiB live, 117.5MiB allocated; 42ms 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)

sample915.0ms (27.1%)

Memory
22.1MiB live, 990.2MiB allocated; 333ms collecting garbage
Samples
702.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 421.0ms
ival-log: 215.0ms (51.1% of total)
ival-hypot: 166.0ms (39.4% of total)
ival-div!: 39.0ms (9.3% of total)
adjust: 2.0ms (0.5% of total)
Bogosity

preprocess160.0ms (4.7%)

Memory
-48.1MiB live, 53.0MiB allocated; 16ms collecting garbage
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
02874
17872
216172
323072
449872
5238772
6716072
Stop Event
1×node-limit
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶51.3%
(/.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
36.2MiB live, 36.1MiB allocated; 0ms collecting garbage
Counts
10 → 79
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 im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (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) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (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))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 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 re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (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) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 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
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)
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)
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)

rewrite181.0ms (5.3%)

Memory
14.3MiB live, 290.8MiB allocated; 37ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03602530
03692390
120102358
089231900
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
89 → 222
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 im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (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) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (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))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 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 re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (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) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 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 (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 (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))))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (sqrt.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) im)
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (fabs.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 im (fabs.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (pow.f64 (*.f64 (neg.f64 im) im) #s(literal 3 binary64))) (fma.f64 (*.f64 re re) (*.f64 re re) (fma.f64 (*.f64 (neg.f64 im) im) (*.f64 (neg.f64 im) im) (*.f64 (*.f64 re re) (*.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))) (neg.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re)))) (neg.f64 (-.f64 (*.f64 im im) (*.f64 re re))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (-.f64 (*.f64 im im) (*.f64 re re)))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im)))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re)))))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (-.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (-.f64 (*.f64 re re) (*.f64 im im))))
(-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (-.f64 (*.f64 im im) (*.f64 re re))) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (-.f64 (*.f64 im im) (*.f64 re re))))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 im) im))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (fma.f64 (*.f64 re re) (*.f64 re re) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 im im))))) (/.f64 (*.f64 (*.f64 (*.f64 im im) 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 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (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) re) (*.f64 (*.f64 re re) re)) (fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 re re))))))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)))
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 re re)
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))))
re
(*.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)))
(*.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)))
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 im im)
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 im) #s(literal 2 binary64))))
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#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)) (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 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 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)))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) im)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 re re)) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (* re re) (*.f64 re re))
#s(approx re re)
#s(approx (/ (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 (pow.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (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 (log.f64 re) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (*.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (*.f64 re re)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (neg.f64 (/.f64 (neg.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) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.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 (neg.f64 (/.f64 (neg.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) (fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 re) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 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)) (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 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 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)))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) re)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 im im)) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re))
#s(approx (* im im) (*.f64 im im))
#s(approx im im)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 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 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (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)) (*.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (neg.f64 (/.f64 (neg.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) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.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 (neg.f64 (/.f64 (neg.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) (fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 im) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)))) #s(literal 1 binary64))))

eval25.0ms (0.8%)

Memory
-3.7MiB live, 54.1MiB allocated; 7ms collecting garbage
Compiler

Compiled 2 493 to 910 computations (63.5% saved)

prune10.0ms (0.3%)

Memory
-22.8MiB live, 23.7MiB allocated; 3ms collecting garbage
Pruning

8 alts after pruning (8 fresh and 0 done)

PrunedKeptTotal
New1998207
Fresh000
Picked101
Done000
Total2008208
Accuracy
99.4%
Counts
208 → 8
Alt Table
Click to see full alt table
StatusAccuracyProgram
51.4%
(/.f64 (neg.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
▶99.0%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶51.3%
(/.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)))
10.7%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
▶98.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶0.0%
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.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) (fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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))))))))
Compiler

Compiled 240 to 222 computations (7.5% saved)

series152.0ms (4.5%)

Memory
-10.8MiB live, 271.6MiB allocated; 36ms collecting garbage
Counts
44 → 137
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 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))
#s(approx (sqrt (+ (* re re) (* im im))) 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)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.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) (fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (/.f64 (neg.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) (fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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)))))))
(neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(neg.f64 (log.f64 (neg.f64 im)))
(log.f64 (neg.f64 im))
(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 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 re re) (*.f64 re re))
(*.f64 re re)
(*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 im im) (*.f64 im im))
#s(literal -1/4 binary64)
(fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64))
(/.f64 (*.f64 re re) (*.f64 im im))
#s(literal 3 binary64)
(/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64)))
#s(literal 120 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 #s(literal 1/2 binary64) (*.f64 re re))
#s(literal 1/2 binary64)
(*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))
Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (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) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))))
#s(approx re #s(hole binary64 re))
#s(approx (+ (* 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 (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (log (neg im)) (log 10))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) #s(hole binary64 (/ (pow re 4) (* (pow im 4) (log 10)))))
#s(approx (* (* re re) (* re re)) #s(hole binary64 (pow re 4)))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (* (pow re 2) (+ (* 1/6 (/ (pow re 4) (* (pow im 6) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) #s(hole binary64 (* 120 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (pow (/ (* re re) (* im im)) 3) #s(hole binary64 (/ (pow re 6) (pow im 6))))
#s(approx (/ (* re re) (* im im)) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (/ (* 1/2 (* re re)) (* (* im im) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (* 1/2 (* re re)) #s(hole binary64 (* 1/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 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* (pow re 6) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (pow re 2) (log 10)))))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* (pow re 6) (- (+ (/ 1/2 (* (pow im 2) (* (pow re 4) (log 10)))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* (pow re 6) (- (+ (* 1/2 (/ 1 (* (pow im 2) (* (pow re 4) (log 10))))) (+ (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (/ (log (neg im)) (* (pow re 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* (pow re 6) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (pow re 2) (log 10)))))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* (pow re 6) (- (+ (/ 1/2 (* (pow im 2) (* (pow re 4) (log 10)))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (* (pow re 6) (+ (* 1/2 (/ 1 (* (pow im 2) (* (pow re 4) (log 10))))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))))))
#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 re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (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) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))))
#s(approx im #s(hole binary64 im))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (* -1/4 (/ (* (pow im 2) (pow re 4)) (log 10))) (* 1/6 (/ (pow re 6) (log 10)))) (pow im 6))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* 1/2 (/ (* (pow im 2) (pow re 2)) (log 10)))))) (pow im 6))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* (pow im 2) (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (+ (log -1) (log im))) (log 10))))))) (pow im 6))))
#s(approx (neg (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (/ (+ (log -1) (log im)) (log 10))))
#s(approx (/ (neg (log (neg im))) (log 10)) #s(hole binary64 (* -1 (/ (+ (log -1) (log im)) (log 10)))))
#s(approx (neg (log (neg im))) #s(hole binary64 (* -1 (+ (log -1) (log im)))))
#s(approx (log (neg im)) #s(hole binary64 (+ (log -1) (log im))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (/ (+ (* -1/4 (/ (* (pow im 2) (pow re 4)) (log 10))) (* 1/6 (/ (pow re 6) (log 10)))) (pow im 6))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* 1/2 (/ (* (pow im 2) (pow re 2)) (log 10)))))) (pow im 6))))
#s(approx (* (* (* im im) (* im im)) (log 10)) #s(hole binary64 (* (pow im 4) (log 10))))
#s(approx (* (* im im) (* im im)) #s(hole binary64 (pow im 4)))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* 1/2 (/ (* (pow im 4) (pow re 2)) (log 10)))) (pow im 6))))
#s(approx (* (* im im) (log 10)) #s(hole binary64 (* (pow im 2) (log 10))))
#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 (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (neg (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))
#s(approx (/ (neg (log (neg im))) (log 10)) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10)))))
#s(approx (neg (log (neg im))) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ 1 im)))))))
#s(approx (log (neg im)) #s(hole binary64 (+ (log -1) (* -1 (log (/ 1 im))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (/ (+ (* -1/4 (/ (pow re 4) (* (pow im 2) (log 10)))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (/ (+ (* -1/4 (/ (pow re 4) (* (pow im 2) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (log 10))))) (pow im 2))))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (log 10)))) (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))))))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (neg (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (neg (log (neg im))) (log 10)) #s(hole binary64 (/ (log (/ -1 im)) (log 10))))
#s(approx (neg (log (neg im))) #s(hole binary64 (log (/ -1 im))))
#s(approx (log (neg im)) #s(hole binary64 (* -1 (log (/ -1 im)))))
Calls

6 calls:

TimeVariablePointExpression
36.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)))) (sqrt (+ (* re re) (* im 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (neg (/ (neg (log (neg im))) (log 10))) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) (* (* re re) (* re re)) (* re re) (* (* (* im im) (* im im)) (log 10)) (* (* im im) (* im im)) -1/4 (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) (pow (/ (* re re) (* im im)) 3) (/ (* re re) (* im im)) 3 (/ 120 (log 10)) 120 1/720 (/ (* 1/2 (* re re)) (* (* im im) (log 10))) (* 1/2 (* re re)) 1/2 (* (* im im) (log 10)))
31.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)))) (sqrt (+ (* re re) (* im 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (neg (/ (neg (log (neg im))) (log 10))) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) (* (* re re) (* re re)) (* re re) (* (* (* im im) (* im im)) (log 10)) (* (* im im) (* im im)) -1/4 (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) (pow (/ (* re re) (* im im)) 3) (/ (* re re) (* im im)) 3 (/ 120 (log 10)) 120 1/720 (/ (* 1/2 (* re re)) (* (* im im) (log 10))) (* 1/2 (* re re)) 1/2 (* (* im im) (log 10)))
24.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)))) (sqrt (+ (* re re) (* im 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (neg (/ (neg (log (neg im))) (log 10))) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) (* (* re re) (* re re)) (* re re) (* (* (* im im) (* im im)) (log 10)) (* (* im im) (* im im)) -1/4 (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) (pow (/ (* re re) (* im im)) 3) (/ (* re re) (* im im)) 3 (/ 120 (log 10)) 120 1/720 (/ (* 1/2 (* re re)) (* (* im im) (log 10))) (* 1/2 (* re re)) 1/2 (* (* im im) (log 10)))
23.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)))) (sqrt (+ (* re re) (* im 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (neg (/ (neg (log (neg im))) (log 10))) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) (* (* re re) (* re re)) (* re re) (* (* (* im im) (* im im)) (log 10)) (* (* im im) (* im im)) -1/4 (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) (pow (/ (* re re) (* im im)) 3) (/ (* re re) (* im im)) 3 (/ 120 (log 10)) 120 1/720 (/ (* 1/2 (* re re)) (* (* im im) (log 10))) (* 1/2 (* re re)) 1/2 (* (* im im) (log 10)))
20.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)))) (sqrt (+ (* re re) (* im 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (neg (/ (neg (log (neg im))) (log 10))) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) (* (* re re) (* re re)) (* re re) (* (* (* im im) (* im im)) (log 10)) (* (* im im) (* im im)) -1/4 (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) (pow (/ (* re re) (* im im)) 3) (/ (* re re) (* im im)) 3 (/ 120 (log 10)) 120 1/720 (/ (* 1/2 (* re re)) (* (* im im) (log 10))) (* 1/2 (* re re)) 1/2 (* (* im im) (log 10)))

rewrite163.0ms (4.8%)

Memory
33.1MiB live, 216.9MiB allocated; 19ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
05615690
06325097
130884809
086274693
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
181 → 557
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 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))
#s(approx (sqrt (+ (* re re) (* im im))) 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)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.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) (fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (/.f64 (neg.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) (fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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)))))))
(neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(neg.f64 (log.f64 (neg.f64 im)))
(log.f64 (neg.f64 im))
(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 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 re re) (*.f64 re re))
(*.f64 re re)
(*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 im im) (*.f64 im im))
#s(literal -1/4 binary64)
(fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64))
(/.f64 (*.f64 re re) (*.f64 im im))
#s(literal 3 binary64)
(/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64)))
#s(literal 120 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 #s(literal 1/2 binary64) (*.f64 re re))
#s(literal 1/2 binary64)
(*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (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) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))))
#s(approx re #s(hole binary64 re))
#s(approx (+ (* 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 (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (log (neg im)) (log 10))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) #s(hole binary64 (/ (pow re 4) (* (pow im 4) (log 10)))))
#s(approx (* (* re re) (* re re)) #s(hole binary64 (pow re 4)))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (* (pow re 2) (+ (* 1/6 (/ (pow re 4) (* (pow im 6) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) #s(hole binary64 (* 120 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (pow (/ (* re re) (* im im)) 3) #s(hole binary64 (/ (pow re 6) (pow im 6))))
#s(approx (/ (* re re) (* im im)) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (/ (* 1/2 (* re re)) (* (* im im) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (* 1/2 (* re re)) #s(hole binary64 (* 1/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 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* (pow re 6) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (pow re 2) (log 10)))))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* (pow re 6) (- (+ (/ 1/2 (* (pow im 2) (* (pow re 4) (log 10)))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* (pow re 6) (- (+ (* 1/2 (/ 1 (* (pow im 2) (* (pow re 4) (log 10))))) (+ (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (/ (log (neg im)) (* (pow re 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* (pow re 6) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (pow re 2) (log 10)))))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (* (pow re 6) (- (+ (/ 1/2 (* (pow im 2) (* (pow re 4) (log 10)))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (* (pow re 6) (+ (* 1/2 (/ 1 (* (pow im 2) (* (pow re 4) (log 10))))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))))))
#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 re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (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) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))))
#s(approx im #s(hole binary64 im))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (* -1/4 (/ (* (pow im 2) (pow re 4)) (log 10))) (* 1/6 (/ (pow re 6) (log 10)))) (pow im 6))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* 1/2 (/ (* (pow im 2) (pow re 2)) (log 10)))))) (pow im 6))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* (pow im 2) (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (+ (log -1) (log im))) (log 10))))))) (pow im 6))))
#s(approx (neg (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (/ (+ (log -1) (log im)) (log 10))))
#s(approx (/ (neg (log (neg im))) (log 10)) #s(hole binary64 (* -1 (/ (+ (log -1) (log im)) (log 10)))))
#s(approx (neg (log (neg im))) #s(hole binary64 (* -1 (+ (log -1) (log im)))))
#s(approx (log (neg im)) #s(hole binary64 (+ (log -1) (log im))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (/ (+ (* -1/4 (/ (* (pow im 2) (pow re 4)) (log 10))) (* 1/6 (/ (pow re 6) (log 10)))) (pow im 6))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* 1/2 (/ (* (pow im 2) (pow re 2)) (log 10)))))) (pow im 6))))
#s(approx (* (* (* im im) (* im im)) (log 10)) #s(hole binary64 (* (pow im 4) (log 10))))
#s(approx (* (* im im) (* im im)) #s(hole binary64 (pow im 4)))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* 1/2 (/ (* (pow im 4) (pow re 2)) (log 10)))) (pow im 6))))
#s(approx (* (* im im) (log 10)) #s(hole binary64 (* (pow im 2) (log 10))))
#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 (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (neg (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))
#s(approx (/ (neg (log (neg im))) (log 10)) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10)))))
#s(approx (neg (log (neg im))) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ 1 im)))))))
#s(approx (log (neg im)) #s(hole binary64 (+ (log -1) (* -1 (log (/ 1 im))))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (/ (+ (* -1/4 (/ (pow re 4) (* (pow im 2) (log 10)))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) #s(hole binary64 (/ (+ (* -1/4 (/ (pow re 4) (* (pow im 2) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (log 10))))) (pow im 2))))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (log 10)))) (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))))))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (neg (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (neg (log (neg im))) (log 10)) #s(hole binary64 (/ (log (/ -1 im)) (log 10))))
#s(approx (neg (log (neg im))) #s(hole binary64 (log (/ -1 im))))
#s(approx (log (neg im)) #s(hole binary64 (* -1 (log (/ -1 im)))))
Outputs
(/.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 (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))))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) 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 (*.f64 re re) re) re (-.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 im re) (*.f64 im re))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im re) (*.f64 im re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) im)
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 im (neg.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (fabs.f64 (fabs.f64 re)))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
re
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))
#s(approx (sqrt (+ (* re re) (* im im))) im)
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))))) (neg.f64 (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 (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)
(/.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 (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))))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im))) (sqrt.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) 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 (*.f64 re re) re) re (-.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 im re) (*.f64 im re))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im re) (*.f64 im re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) im)
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 (neg.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 im (neg.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (fabs.f64 (fabs.f64 re)))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im))) (neg.f64 (-.f64 (*.f64 re re) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) 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 (*.f64 re re) re) re (-.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 im re) (*.f64 im re))))))
(/.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 (*.f64 im im) im) im (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im re) (*.f64 im re))))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) 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 (*.f64 re re) re) re (-.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 im re) (*.f64 im re)))))
(/.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 (*.f64 im im) im) im (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im re) (*.f64 im re)))))
(fma.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (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 (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 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)))
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 im im)
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 im #s(literal 2 binary64))
(sqrt.f64 (*.f64 (*.f64 (*.f64 im im) im) im))
(fabs.f64 (neg.f64 (*.f64 im im)))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 im) #s(literal 2 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.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)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (*.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))) #s(literal 2 binary64))) (-.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (pow.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (*.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))))))
(fma.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))))
(fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))))
(+.f64 (+.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))
(+.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.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))))
(+.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))))
(*.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(+.f64 (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (log.f64 (neg.f64 im)))
(*.f64 (log.f64 (neg.f64 im)) #s(literal -1 binary64))
(neg.f64 (log.f64 (neg.f64 im)))
(fma.f64 (log.f64 #s(literal -1 binary64)) #s(literal -1 binary64) (*.f64 (log.f64 im) #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (neg.f64 im)))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))
(+.f64 (*.f64 (log.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (*.f64 (log.f64 im) #s(literal -1 binary64)))
(+.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(log.f64 (/.f64 #s(literal -1 binary64) im))
(/.f64 (neg.f64 (-.f64 (*.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal -1 binary64))) (*.f64 (log.f64 im) (log.f64 im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 #s(literal -1 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal -1 binary64)) (-.f64 (*.f64 (log.f64 im) (log.f64 im)) (*.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))))))
(/.f64 (-.f64 (*.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal -1 binary64))) (*.f64 (log.f64 im) (log.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))
(/.f64 (+.f64 (pow.f64 (log.f64 #s(literal -1 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (fma.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal -1 binary64)) (-.f64 (*.f64 (log.f64 im) (log.f64 im)) (*.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im)))))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (log.f64 im))
(-.f64 (log.f64 #s(literal -1 binary64)) (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))
(+.f64 (log.f64 im) (log.f64 #s(literal -1 binary64)))
(log.f64 (neg.f64 im))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) #s(literal 3 binary64)) #s(literal -1/64 binary64) (pow.f64 (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))))
(/.f64 (fma.f64 (pow.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) #s(literal 3 binary64)) #s(literal -1/64 binary64) (pow.f64 (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))))))
(fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))
(fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))
(+.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))
(+.f64 (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))
(+.f64 (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) im) im)) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (*.f64 (neg.f64 (*.f64 re re)) (*.f64 re re)) (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 im im) im) im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (*.f64 re re) (neg.f64 (*.f64 re re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re))) (neg.f64 (neg.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (neg.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 im im) im) im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (neg.f64 (*.f64 re re))) (neg.f64 (neg.f64 (*.f64 re re))))
(*.f64 (neg.f64 (*.f64 re re)) (neg.f64 (*.f64 re re)))
(*.f64 (*.f64 (*.f64 re re) re) re)
(*.f64 (*.f64 re re) (*.f64 re re))
(*.f64 re (*.f64 (*.f64 re re) re))
(pow.f64 (neg.f64 (*.f64 re re)) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 2 binary64))
(pow.f64 re #s(literal 4 binary64))
(fabs.f64 (*.f64 (*.f64 (*.f64 re re) re) re))
(exp.f64 (fma.f64 (log.f64 re) #s(literal 2 binary64) (*.f64 (log.f64 re) #s(literal 2 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 re) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 re) #s(literal 4 binary64))))
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 re re)
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(sqrt.f64 (*.f64 (*.f64 (*.f64 re re) re) re))
(fabs.f64 (neg.f64 (*.f64 re re)))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))))
(*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) im) im))
(log.f64 (pow.f64 #s(literal 10 binary64) (*.f64 (*.f64 (*.f64 im im) im) im)))
(*.f64 (neg.f64 (neg.f64 (*.f64 im im))) (neg.f64 (neg.f64 (*.f64 im im))))
(*.f64 (neg.f64 (*.f64 im im)) (neg.f64 (*.f64 im im)))
(*.f64 (*.f64 (*.f64 im im) im) im)
(*.f64 (*.f64 im im) (*.f64 im im))
(*.f64 im (*.f64 (*.f64 im im) im))
(pow.f64 (neg.f64 (*.f64 im im)) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 2 binary64))
(pow.f64 im #s(literal 4 binary64))
(fabs.f64 (*.f64 (*.f64 (*.f64 im im) im) im))
(exp.f64 (fma.f64 (log.f64 im) #s(literal 2 binary64) (*.f64 (log.f64 im) #s(literal 2 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 im) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 im) #s(literal 4 binary64))))
#s(literal -1/4 binary64)
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 3 binary64)) #s(literal 1/373248000 binary64) (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) #s(literal 1/8 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))))))
(/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)) #s(literal 2 binary64))) (-.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))
(/.f64 (fma.f64 (pow.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 3 binary64)) #s(literal 1/373248000 binary64) (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) #s(literal 1/8 binary64))) (+.f64 (pow.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))))
(fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))))
(fma.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))
(fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))
(fma.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/720 binary64)) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))
(-.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))
(+.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))
(+.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)) (*.f64 #s(literal 1/720 binary64) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))))
(*.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 120 binary64))
(*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))
(*.f64 #s(literal 120 binary64) (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 #s(literal -120 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))
(/.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 1/10 binary64))))
(/.f64 (neg.f64 (*.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) #s(literal 120 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.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)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 #s(literal 120 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)))) (neg.f64 (neg.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64))))))
(/.f64 (*.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal 120 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64))) (neg.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64)))))
(/.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))) (log.f64 #s(literal 10 binary64)))
(/.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))))
(+.f64 (/.f64 (*.f64 #s(literal 30 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 90 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64)))))
(*.f64 (fabs.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3/2 binary64))) (fabs.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3/2 binary64))))
(*.f64 (neg.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3/2 binary64))) (neg.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 3 binary64)) (pow.f64 (/.f64 re im) #s(literal 3 binary64)))
(*.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3/2 binary64)) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3/2 binary64)))
(*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) (*.f64 re (/.f64 re (*.f64 im im))))
(*.f64 (*.f64 (*.f64 re re) re) (pow.f64 (/.f64 re (*.f64 im im)) #s(literal 3 binary64)))
(*.f64 (*.f64 re (/.f64 re (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)))
(pow.f64 (exp.f64 (log.f64 (*.f64 re (/.f64 re (*.f64 im im))))) #s(literal 3 binary64))
(pow.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal 3/2 binary64))
(pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))
(/.f64 (neg.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (neg.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))))
(/.f64 (pow.f64 (neg.f64 (*.f64 re re)) #s(literal 3 binary64)) (pow.f64 (neg.f64 (*.f64 im im)) #s(literal 3 binary64)))
(/.f64 (pow.f64 (/.f64 (*.f64 re re) im) #s(literal 3 binary64)) (*.f64 (*.f64 im im) im))
(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (neg.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))
(/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))
(exp.f64 (-.f64 (*.f64 (log.f64 re) #s(literal 6 binary64)) (*.f64 (log.f64 im) #s(literal 6 binary64))))
(exp.f64 (*.f64 (log.f64 (*.f64 re (/.f64 re (*.f64 im im)))) #s(literal 3 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (*.f64 re (/.f64 re (*.f64 im im)))) #s(literal 3 binary64))) (sinh.f64 (*.f64 (log.f64 (*.f64 re (/.f64 re (*.f64 im im)))) #s(literal 3 binary64))))
(*.f64 (fabs.f64 (/.f64 re im)) (fabs.f64 (/.f64 re im)))
(*.f64 (neg.f64 (/.f64 re im)) (neg.f64 (/.f64 re im)))
(*.f64 (/.f64 re im) (/.f64 re im))
(*.f64 re (/.f64 re (*.f64 im im)))
(pow.f64 (/.f64 re im) #s(literal 2 binary64))
(/.f64 (neg.f64 (/.f64 (*.f64 re re) im)) (neg.f64 im))
(/.f64 (neg.f64 (neg.f64 (*.f64 re re))) (neg.f64 (neg.f64 (*.f64 im im))))
(/.f64 (neg.f64 (*.f64 re re)) (neg.f64 (*.f64 im im)))
(/.f64 (/.f64 (*.f64 re re) im) im)
(/.f64 (*.f64 re re) (*.f64 im im))
(exp.f64 (-.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)) (*.f64 (log.f64 im) #s(literal 2 binary64))))
#s(literal 3 binary64)
(/.f64 #s(literal -120 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 120 binary64) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64)))
#s(literal 120 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 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (neg.f64 (*.f64 re re))) (*.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re))) (neg.f64 (neg.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))
(/.f64 (neg.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re)) (neg.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) re) re)
(*.f64 (*.f64 re re) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (*.f64 re re))
#s(literal 1/2 binary64)
(*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im im))
(*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))
(log.f64 (pow.f64 #s(literal 10 binary64) (*.f64 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)) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) 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 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 (*.f64 im im) 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 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 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) im)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 re re)) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im))
#s(approx re re)
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 (*.f64 im im) 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) 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)))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (*.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 (*.f64 im im) 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)))
#s(approx (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))))
#s(approx (* (* re re) (* re re)) (*.f64 (*.f64 (*.f64 re re) re) re))
#s(approx (* re re) (*.f64 re re))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 re re)))
#s(approx (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))))
#s(approx (pow (/ (* re re) (* im im)) 3) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)))
#s(approx (/ (* re re) (* im im)) (*.f64 re (/.f64 re (*.f64 im im))))
#s(approx (/ (* 1/2 (* re re)) (* (* im im) (log 10))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))
#s(approx (* 1/2 (* re re)) (*.f64 (*.f64 #s(literal 1/2 binary64) 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 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 (*.f64 re re) 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 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 (*.f64 re re) 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 (log.f64 re) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) 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 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 3 binary64)) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (*.f64 (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1 binary64)) (*.f64 re re)))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (*.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64)))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (*.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (*.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 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 im im) im) im)))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (*.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im))) (/.f64 #s(literal 1/6 binary64) (*.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 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 im im) im) im)))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (*.f64 (-.f64 (+.f64 (+.f64 (/.f64 (log.f64 (neg.f64 im)) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 im im) im) im)))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (*.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64)))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (*.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (*.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 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 im im) im) im)))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (*.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im))) (/.f64 #s(literal 1/6 binary64) (*.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 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 im im) im) im)))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (*.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64)))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (*.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im))) (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64))))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (neg.f64 (/.f64 (neg.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) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 (*.f64 re re) 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 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 (*.f64 re re) 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))))))))
#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 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) 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 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) 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 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) 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 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) 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 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)) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 (*.f64 re re) 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 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 (*.f64 re re) 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 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)))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) re)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 im im)) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re))
#s(approx im im)
#s(approx (neg im) (neg.f64 im))
#s(approx (* im im) (*.f64 im im))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im re) (*.f64 im re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (fma.f64 (fma.f64 (fma.f64 (*.f64 im im) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (log.f64 #s(literal 10 binary64)))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))
#s(approx (neg (/ (neg (log (neg im))) (log 10))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (neg im))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (log.f64 (neg.f64 im)))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (/.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im re) (*.f64 im re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))
#s(approx (* (* (* im im) (* im im)) (log 10)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))
#s(approx (* (* im im) (* im im)) (*.f64 (*.f64 (*.f64 im im) im) im))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))
#s(approx (* (* im im) (log 10)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))
#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 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) 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 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (*.f64 re (/.f64 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 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (*.f64 im im))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) 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 (*.f64 #s(literal 1/2 binary64) re) re) (*.f64 im im)))) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (fma.f64 (*.f64 re (/.f64 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 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (*.f64 im im))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/16 binary64) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (*.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (+ (* re re) (* im im)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (-.f64 (fma.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (*.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 10 binary64))))))
#s(approx (neg (/ (neg (log (neg im))) (log 10))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (neg im))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (log.f64 (neg.f64 im)))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (log.f64 #s(literal 10 binary64)))) (*.f64 im im)))
#s(approx (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10))))) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (log.f64 #s(literal 10 binary64))))) (*.f64 im im)))
#s(approx (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (log.f64 #s(literal 10 binary64)))) (*.f64 im im)))
#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 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) 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 10)) (+.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64))) #s(literal 1/720 binary64) (*.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)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (*.f64 re (/.f64 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 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) 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 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) 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 (*.f64 #s(literal 1/2 binary64) 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 re (/.f64 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 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) 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 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/16 binary64) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) re) (*.f64 im im)))) #s(literal 1 binary64))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))) (-.f64 (fma.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (*.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 10 binary64))))))
#s(approx (neg (/ (neg (log (neg im))) (log 10))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (neg im))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))

eval70.0ms (2.1%)

Memory
8.4MiB live, 130.6MiB allocated; 37ms collecting garbage
Compiler

Compiled 7 557 to 2 432 computations (67.8% saved)

prune21.0ms (0.6%)

Memory
1.9MiB live, 46.8MiB allocated; 11ms collecting garbage
Pruning

10 alts after pruning (6 fresh and 4 done)

PrunedKeptTotal
New4363439
Fresh033
Picked145
Done000
Total43710447
Accuracy
99.5%
Counts
447 → 10
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶51.4%
(/.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.0%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓99.0%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓51.3%
(/.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)))
▶10.7%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
✓98.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
0.0%
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 (*.f64 im im) 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
Compiler

Compiled 325 to 281 computations (13.5% saved)

series47.0ms (1.4%)

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

6 calls:

TimeVariablePointExpression
30.0ms
im
@0
((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) im (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (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
@0
((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) im (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (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
((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) im (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
2.0ms
im
@inf
((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) im (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
2.0ms
re
@-inf
((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) im (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg re) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))

rewrite208.0ms (6.2%)

Memory
17.6MiB live, 209.0MiB allocated; 75ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

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

eval81.0ms (2.4%)

Memory
-3.3MiB live, 44.4MiB allocated; 8ms collecting garbage
Compiler

Compiled 3 758 to 1 239 computations (67% saved)

prune10.0ms (0.3%)

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

12 alts after pruning (3 fresh and 9 done)

PrunedKeptTotal
New2642266
Fresh011
Picked055
Done044
Total26412276
Accuracy
99.7%
Counts
276 → 12
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓51.4%
(/.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.0%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
▶0.0%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
▶10.7%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re))) (log.f64 #s(literal 1/10 binary64)))
✓99.0%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓51.3%
(/.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)))
✓10.7%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
✓98.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶0.0%
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 (*.f64 im im) 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
Compiler

Compiled 207 to 185 computations (10.6% saved)

series170.0ms (5%)

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

6 calls:

TimeVariablePointExpression
44.0ms
im
@-inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (* 1/6 (* re re)) 1/6 (* re re) re (* (* (* (* im im) im) (* (* im im) im)) (log 10)) (* (* (* im im) im) (* (* im im) im)) (* (* im im) im) (* im im) im (log 10) 10 (/ 1/4 (* (* (* (* im im) im) im) (log 10))) 1/4 (* (* (* (* im im) im) im) (log 10)) (* (* (* im im) im) im) (/ 1/2 (* (* im im) (log 10))) 1/2 (* (* im im) (log 10)) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg re))
27.0ms
re
@inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (* 1/6 (* re re)) 1/6 (* re re) re (* (* (* (* im im) im) (* (* im im) im)) (log 10)) (* (* (* im im) im) (* (* im im) im)) (* (* im im) im) (* im im) im (log 10) 10 (/ 1/4 (* (* (* (* im im) im) im) (log 10))) 1/4 (* (* (* (* im im) im) im) (log 10)) (* (* (* im im) im) im) (/ 1/2 (* (* im im) (log 10))) 1/2 (* (* im im) (log 10)) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg re))
22.0ms
re
@-inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (* 1/6 (* re re)) 1/6 (* re re) re (* (* (* (* im im) im) (* (* im im) im)) (log 10)) (* (* (* im im) im) (* (* im im) im)) (* (* im im) im) (* im im) im (log 10) 10 (/ 1/4 (* (* (* (* im im) im) im) (log 10))) 1/4 (* (* (* (* im im) im) im) (log 10)) (* (* (* im im) im) im) (/ 1/2 (* (* im im) (log 10))) 1/2 (* (* im im) (log 10)) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg re))
20.0ms
im
@inf
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (* 1/6 (* re re)) 1/6 (* re re) re (* (* (* (* im im) im) (* (* im im) im)) (log 10)) (* (* (* im im) im) (* (* im im) im)) (* (* im im) im) (* im im) im (log 10) 10 (/ 1/4 (* (* (* (* im im) im) im) (log 10))) 1/4 (* (* (* (* im im) im) im) (log 10)) (* (* (* im im) im) im) (/ 1/2 (* (* im im) (log 10))) 1/2 (* (* im im) (log 10)) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg re))
19.0ms
im
@0
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (* 1/6 (* re re)) 1/6 (* re re) re (* (* (* (* im im) im) (* (* im im) im)) (log 10)) (* (* (* im im) im) (* (* im im) im)) (* (* im im) im) (* im im) im (log 10) 10 (/ 1/4 (* (* (* (* im im) im) im) (log 10))) 1/4 (* (* (* (* im im) im) im) (log 10)) (* (* (* im im) im) im) (/ 1/2 (* (* im im) (log 10))) 1/2 (* (* im im) (log 10)) (/ (neg (log (neg im))) (log 10)) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (neg re))

rewrite791.0ms (23.4%)

Memory
-78.8MiB live, 388.0MiB allocated; 1.0s collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
079310446
08549134
144048828
083187904
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
247 → 409
Calls
Call 1
Inputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 (*.f64 im im) 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 (*.f64 im im) 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
(-.f64 (*.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 (*.f64 im im) 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(*.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 (*.f64 im im) 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))
(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 (*.f64 im im) 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 (/.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 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))))
(/.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/6 binary64) (*.f64 re re))
#s(literal 1/6 binary64)
(*.f64 re re)
re
(*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))
(*.f64 (*.f64 im im) im)
(*.f64 im im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64))))
#s(literal 1/4 binary64)
(*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (*.f64 im im) im) im)
(/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))
#s(literal 1/2 binary64)
(*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(neg.f64 (log.f64 (neg.f64 im)))
(log.f64 (neg.f64 im))
(neg.f64 im)
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re))
#s(approx (sqrt (+ (* im im) (* re re))) re)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re)))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))
(neg.f64 re)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (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) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (log (neg im)) (log 10))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (/ (log (neg im)) (log 10))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (- (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (- (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (* -1 (/ (log (neg im)) (log 10))))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (/ 1/2 (* (pow im 2) (log 10)))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) #s(hole binary64 (/ -1/4 (* (pow im 4) (log 10)))))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) #s(hole binary64 (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))))
#s(approx (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) #s(hole binary64 (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10))))))
#s(approx (* 1/6 (* re re)) #s(hole binary64 (* 1/6 (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 im))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))))
#s(approx (neg re) #s(hole binary64 (* -1 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 (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* (pow re 6) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (pow re 2) (log 10)))))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* (pow re 6) (- (+ (/ 1/2 (* (pow im 2) (* (pow re 4) (log 10)))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* (pow re 6) (- (+ (* 1/2 (/ 1 (* (pow im 2) (* (pow re 4) (log 10))))) (+ (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (/ (log (neg im)) (* (pow re 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (* (pow re 6) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (pow re 2) (log 10)))))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (* (pow re 6) (- (+ (/ 1/2 (* (pow im 2) (* (pow re 4) (log 10)))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (* (pow re 6) (- (+ (* 1/2 (/ 1 (* (pow im 2) (* (pow re 4) (log 10))))) (+ (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (/ (log (neg im)) (* (pow re 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10))))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (* (pow re 6) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (pow re 2) (log 10)))))))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (* (pow re 6) (- (+ (/ 1/2 (* (pow im 2) (* (pow re 4) (log 10)))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (* 1/6 (/ (pow re 4) (* (pow im 6) (log 10))))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (* (pow re 4) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (pow re 2) (log 10)))))))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (* (pow re 4) (- (+ (/ 1/2 (* (pow im 2) (* (pow re 4) (log 10)))) (* 1/6 (/ 1 (* (pow im 6) (log 10))))) (/ 1/4 (* (pow im 4) (* (pow re 2) (log 10))))))))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) #s(hole binary64 (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10))))))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) #s(hole binary64 (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (pow re 2) (log 10)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #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 (+ (* im im) (* re re))))) #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 (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 re))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (/ (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 (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #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 (+ (* im im) (* re re))))) #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 (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (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) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (* -1/4 (/ (* (pow im 2) (pow re 4)) (log 10))) (* 1/6 (/ (pow re 6) (log 10)))) (pow im 6))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* 1/2 (/ (* (pow im 2) (pow re 2)) (log 10)))))) (pow im 6))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* (pow im 2) (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (+ (log -1) (log im))) (log 10))))))) (pow im 6))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (/ (+ (* -1/4 (/ (* (pow im 2) (pow re 4)) (log 10))) (* 1/6 (/ (pow re 6) (log 10)))) (pow im 6))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* 1/2 (/ (* (pow im 2) (pow re 2)) (log 10)))))) (pow im 6))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* (pow im 2) (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (+ (log -1) (log im))) (log 10))))))) (pow im 6))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (/ (+ (* -1/4 (/ (* (pow im 2) (pow re 4)) (log 10))) (* 1/6 (/ (pow re 6) (log 10)))) (pow im 6))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 6) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 4) (log 10))) (* 1/2 (/ (* (pow im 2) (pow re 2)) (log 10)))))) (pow im 6))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (/ (+ (* -1/4 (/ (* (pow im 2) (pow re 2)) (log 10))) (* 1/6 (/ (pow re 4) (log 10)))) (pow im 6))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (/ (+ (* 1/6 (/ (pow re 4) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow re 2) (log 10))) (* 1/2 (/ (pow im 2) (log 10)))))) (pow im 6))))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) #s(hole binary64 (/ (+ (* -1/4 (/ (pow im 2) (log 10))) (* 1/6 (/ (pow re 2) (log 10)))) (pow im 6))))
#s(approx (* (* (* (* im im) im) (* (* im im) im)) (log 10)) #s(hole binary64 (* (pow im 6) (log 10))))
#s(approx (* (* (* im im) im) (* (* im im) im)) #s(hole binary64 (pow im 6)))
#s(approx (* (* im im) im) #s(hole binary64 (pow im 3)))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (/ 1/4 (* (* (* (* im im) im) im) (log 10))) #s(hole binary64 (/ 1/4 (* (pow im 4) (log 10)))))
#s(approx (* (* (* (* im im) im) im) (log 10)) #s(hole binary64 (* (pow im 4) (log 10))))
#s(approx (* (* (* im im) im) im) #s(hole binary64 (pow im 4)))
#s(approx (/ 1/2 (* (* im im) (log 10))) #s(hole binary64 (/ 1/2 (* (pow im 2) (log 10)))))
#s(approx (* (* im im) (log 10)) #s(hole binary64 (* (pow im 2) (log 10))))
#s(approx (/ (neg (log (neg im))) (log 10)) #s(hole binary64 (* -1 (/ (+ (log -1) (log im)) (log 10)))))
#s(approx (neg (log (neg im))) #s(hole binary64 (* -1 (+ (log -1) (log im)))))
#s(approx (log (neg im)) #s(hole binary64 (+ (log -1) (log im))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log re) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))) (log re))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))))
#s(approx (/ (log (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 (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10))))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (/ (+ (* -1/4 (/ (pow re 4) (* (pow im 2) (log 10)))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) #s(hole binary64 (/ (+ (* -1/4 (/ (pow re 4) (* (pow im 2) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (log 10))))) (pow im 2))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (/ (+ (* -1/4 (/ (pow re 2) (* (pow im 2) (log 10)))) (* 1/2 (/ 1 (log 10)))) (pow im 2))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) #s(hole binary64 (/ (+ (* -1/4 (/ (pow re 2) (* (pow im 2) (log 10)))) (+ (* 1/6 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (log 10))))) (pow im 2))))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) #s(hole binary64 (/ (- (* 1/6 (/ (pow re 2) (* (pow im 2) (log 10)))) (* 1/4 (/ 1 (log 10)))) (pow im 4))))
#s(approx (/ (neg (log (neg im))) (log 10)) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ 1 im)))) (log 10)))))
#s(approx (neg (log (neg im))) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ 1 im)))))))
#s(approx (log (neg im)) #s(hole binary64 (+ (log -1) (* -1 (log (/ 1 im))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #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 (+ (* im im) (* re re))))) #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 (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (/ (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 (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) #s(hole binary64 (- (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (neg (log (neg im))) (log 10)) #s(hole binary64 (/ (log (/ -1 im)) (log 10))))
#s(approx (neg (log (neg im))) #s(hole binary64 (log (/ -1 im))))
#s(approx (log (neg im)) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #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 (+ (* im im) (* re re))))) #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 (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))))
Outputs
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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)) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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)) #s(literal 3 binary64)) (pow.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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)) #s(literal 2 binary64)) (+.f64 (pow.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))))
(fma.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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))))) re) re (*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 #s(literal 1 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (*.f64 re re) (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 #s(literal 1 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))
(-.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 #s(literal 1 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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))))) re) re)
(*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 (*.f64 re re) (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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))))))
(fma.f64 (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) (*.f64 re re) (*.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 re re)))
(fma.f64 (*.f64 re re) (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) (*.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))
(+.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re)) (*.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))
(+.f64 (*.f64 (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) (*.f64 re re)) (*.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 re re)))
(/.f64 (-.f64 (pow.f64 (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) #s(literal 2 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) (-.f64 (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))
(/.f64 (+.f64 (pow.f64 (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) #s(literal 2 binary64)) (-.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))))
(fma.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re))
(fma.f64 (*.f64 re re) (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re))
(-.f64 (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))
(+.f64 (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
(+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) re) re))
(/.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) #s(literal 2 binary64)) (pow.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(/.f64 (-.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) #s(literal 1/216 binary64)) (pow.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) #s(literal 2 binary64)) (+.f64 (pow.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64))) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/4 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (*.f64 #s(literal -1/4 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(fma.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/4 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(+.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (*.f64 #s(literal -1/4 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(*.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64))
(*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64))) (neg.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(/.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))) #s(literal 1/6 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal 1/6 binary64) re) re)
(*.f64 (*.f64 re re) #s(literal 1/6 binary64))
(*.f64 #s(literal 1/6 binary64) (*.f64 re re))
#s(literal 1/6 binary64)
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 re re)
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 re #s(literal 2 binary64))
(fabs.f64 (neg.f64 (*.f64 re re)))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))))
re
(*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)))
(log.f64 (pow.f64 #s(literal 10 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
(*.f64 (neg.f64 (neg.f64 (*.f64 (*.f64 im im) im))) (neg.f64 (neg.f64 (*.f64 (*.f64 im im) im))))
(*.f64 (pow.f64 (*.f64 (*.f64 im im) im) #s(literal 1 binary64)) (pow.f64 (*.f64 (*.f64 im im) im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 (*.f64 im im) im) #s(literal 1 binary64)) (*.f64 (*.f64 im im) im))
(*.f64 (pow.f64 (fabs.f64 im) #s(literal 3 binary64)) (pow.f64 (fabs.f64 im) #s(literal 3 binary64)))
(*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 im im)) im)
(*.f64 (neg.f64 (*.f64 (*.f64 im im) im)) (neg.f64 (*.f64 (*.f64 im im) im)))
(*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))
(*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))
(*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))
(pow.f64 (neg.f64 (*.f64 (*.f64 im im) im)) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 3 binary64))
(pow.f64 (*.f64 (*.f64 im im) im) #s(literal 2 binary64))
(pow.f64 im #s(literal 6 binary64))
(fabs.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)))
(exp.f64 (fma.f64 (log.f64 im) #s(literal 4 binary64) (*.f64 (log.f64 im) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 im) #s(literal 2 binary64) (*.f64 (log.f64 im) #s(literal 4 binary64))))
(exp.f64 (fma.f64 (log.f64 im) #s(literal 3 binary64) (*.f64 (log.f64 im) #s(literal 3 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 3 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 3 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (*.f64 im im) im)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 6 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 im) #s(literal 6 binary64))) (sinh.f64 (*.f64 (log.f64 im) #s(literal 6 binary64))))
(*.f64 (neg.f64 (pow.f64 im #s(literal 3/2 binary64))) (neg.f64 (pow.f64 im #s(literal 3/2 binary64))))
(*.f64 (fabs.f64 (pow.f64 im #s(literal 3/2 binary64))) (fabs.f64 (pow.f64 im #s(literal 3/2 binary64))))
(*.f64 (pow.f64 im #s(literal 3/2 binary64)) (pow.f64 im #s(literal 3/2 binary64)))
(*.f64 (fabs.f64 im) (*.f64 im im))
(*.f64 (*.f64 im im) (fabs.f64 im))
(*.f64 (*.f64 im im) im)
(*.f64 im (*.f64 im im))
(pow.f64 (pow.f64 im #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 3/2 binary64))
(pow.f64 im #s(literal 3 binary64))
(fabs.f64 (neg.f64 (*.f64 (*.f64 im im) im)))
(fabs.f64 (*.f64 (*.f64 im im) im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 3 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 im) #s(literal 3 binary64))) (sinh.f64 (*.f64 (log.f64 im) #s(literal 3 binary64))))
(*.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)))
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 im im)
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 im #s(literal 2 binary64))
(fabs.f64 (neg.f64 (*.f64 im im)))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 im) #s(literal 2 binary64))))
im
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/4 binary64))
(*.f64 #s(literal 1/4 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(/.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 im im) (*.f64 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 #s(literal -1/4 binary64) (neg.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
#s(literal 1/4 binary64)
(*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (*.f64 im im) im) (*.f64 im (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))
(log.f64 (pow.f64 #s(literal 10 binary64) (*.f64 (*.f64 im im) (*.f64 im im))))
(*.f64 (neg.f64 (neg.f64 (*.f64 im im))) (neg.f64 (neg.f64 (*.f64 im im))))
(*.f64 (neg.f64 (*.f64 im im)) (neg.f64 (*.f64 im im)))
(*.f64 (*.f64 im im) (*.f64 im im))
(*.f64 (*.f64 (*.f64 im im) im) im)
(*.f64 im (*.f64 (*.f64 im im) im))
(pow.f64 (neg.f64 (*.f64 im im)) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 2 binary64))
(pow.f64 im #s(literal 4 binary64))
(fabs.f64 (*.f64 (*.f64 im im) (*.f64 im im)))
(exp.f64 (fma.f64 (log.f64 im) #s(literal 2 binary64) (*.f64 (log.f64 im) #s(literal 2 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 im) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 im) #s(literal 4 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1/2 binary64) (neg.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))
#s(literal 1/2 binary64)
(*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im im))
(*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))
(log.f64 (pow.f64 #s(literal 10 binary64) (*.f64 im im)))
(*.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (log.f64 (neg.f64 im)))
(*.f64 (log.f64 (neg.f64 im)) #s(literal -1 binary64))
(neg.f64 (log.f64 (neg.f64 im)))
(fma.f64 (log.f64 #s(literal -1 binary64)) #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (neg.f64 im)))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))
(+.f64 (*.f64 (log.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(+.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(log.f64 (/.f64 #s(literal -1 binary64) im))
(/.f64 (-.f64 (*.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal -1 binary64))) (*.f64 (log.f64 im) (log.f64 im))) (neg.f64 (log.f64 (neg.f64 im))))
(/.f64 (+.f64 (pow.f64 (log.f64 #s(literal -1 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (fma.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal -1 binary64)) (-.f64 (*.f64 (log.f64 im) (log.f64 im)) (*.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im)))))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (log.f64 im))
(-.f64 (log.f64 #s(literal -1 binary64)) (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))
(+.f64 (log.f64 im) (log.f64 #s(literal -1 binary64)))
(log.f64 (neg.f64 im))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(neg.f64 im)
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re)))
(log.f64 (/.f64 #s(literal 1 binary64) #s(approx (sqrt (+ (* im im) (* re re))) re)))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re))
#s(approx (sqrt (+ (* im im) (* re re))) re)
(neg.f64 (log.f64 #s(literal 10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))))
(log.f64 (/.f64 #s(literal 1 binary64) #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re)))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))
(*.f64 #s(literal -1 binary64) re)
(*.f64 re #s(literal -1 binary64))
(neg.f64 re)
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (-.f64 (*.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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (-.f64 (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (*.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)))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (*.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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)))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (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))))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 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))))))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)))
#s(approx (* 1/6 (* re re)) (*.f64 (*.f64 re re) #s(literal 1/6 binary64)))
#s(approx (* re re) (*.f64 re re))
#s(approx re re)
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 re re)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im)))) (*.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.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 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.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 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 (-.f64 (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re re)) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re)) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) im)
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) im)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 im im))) #s(literal 1/16 binary64)) (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im))
#s(approx (neg re) (neg.f64 re))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 (*.f64 re re) 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 (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 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 (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (*.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64)))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (*.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (*.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im))) (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (*.f64 (-.f64 (+.f64 (+.f64 (/.f64 (log.f64 (neg.f64 im)) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (*.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64)))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (*.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (*.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im))) (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (*.f64 (-.f64 (+.f64 (+.f64 (/.f64 (log.f64 (neg.f64 im)) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (*.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64)))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (*.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (*.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im))) (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (*.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) re)))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (*.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) (*.f64 im im))) (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) re) re)))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64)))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (*.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 re re)))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (*.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (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 (*.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal -1/720 binary64)) (log.f64 re)) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 re))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 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 (+ (* im im) (* re re))) re)
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (exp.f64 (-.f64 (*.f64 (log.f64 im) #s(literal 6 binary64)) (*.f64 (log.f64 re) #s(literal 6 binary64)))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (*.f64 re re) 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 (+ (* im im) (* re re))))) (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 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 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))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (+ (* im im) (* re re))))) (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 (*.f64 re re) 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 (+ (* im im) (* re re))))) (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 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (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 (*.f64 re re) 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 (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* 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 (+ (* im im) (* re re))))) (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) 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 (+ (* im im) (* re re))))) (-.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal -1/720 binary64)) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (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 (+ (* im im) (* re re)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 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 (+ (* im im) (* re re))) (neg.f64 re))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 re) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/8 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (exp.f64 (-.f64 (*.f64 (log.f64 im) #s(literal 6 binary64)) (*.f64 (log.f64 re) #s(literal 6 binary64)))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 (*.f64 re re) 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 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/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 (*.f64 re re) 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 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im re) (*.f64 im re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (fma.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (/.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im re) (*.f64 im re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (/.f64 (fma.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im re) (*.f64 im re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im re) (*.f64 im re)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (/.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/.f64 (fma.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))))
#s(approx (* (* (* (* im im) im) (* (* im im) im)) (log 10)) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
#s(approx (* (* (* im im) im) (* (* im im) im)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)))
#s(approx (* (* im im) im) (*.f64 (*.f64 im im) im))
#s(approx (* im im) (*.f64 im im))
#s(approx im im)
#s(approx (/ 1/4 (* (* (* (* im im) im) im) (log 10))) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (* (* (* (* im im) im) im) (log 10)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
#s(approx (* (* (* im im) im) im) (*.f64 (*.f64 im im) (*.f64 im im)))
#s(approx (/ 1/2 (* (* im im) (log 10))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))
#s(approx (* (* im im) (log 10)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (neg im))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (log.f64 (neg.f64 im)))
#s(approx (neg im) (neg.f64 im))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (*.f64 (*.f64 (*.f64 re re) 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 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 (*.f64 re re) 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 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/4 binary64)) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 (-.f64 (*.f64 (fma.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 (*.f64 re re) re) re))) (*.f64 im im)) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im)) (log.f64 re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 re))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/6 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) re)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 im im)) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (+.f64 (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (+.f64 (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.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) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (-.f64 (fma.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (-.f64 (fma.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im)))
#s(approx (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))) (*.f64 im im)))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (/.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 im im)))
#s(approx (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (/.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal 1/6 binary64) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (*.f64 im im)))
#s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (*.f64 im im))))
#s(approx (/ (neg (log (neg im))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (log.f64 (neg.f64 im)))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (*.f64 re re) re) re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/4 binary64)) (fma.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) (log.f64 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))) #s(literal -1/720 binary64)) (log.f64 im)) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im))) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) 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) (*.f64 im im)) (*.f64 im im))) #s(literal 1/720 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)))) (log.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (fma.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/16 binary64) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (+.f64 (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (+.f64 (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.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) (*.f64 im im)) (*.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (-.f64 (fma.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (- (* (+ (* (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (* re re)) (/ 1/2 (* (* im im) (log 10)))) (* re re)) (/ (neg (log (neg im))) (log 10))) (fma.f64 (*.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))))) #s(literal -1/4 binary64) (-.f64 (fma.f64 (/.f64 (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (log (neg im))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (*.f64 re re) re) re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (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 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.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 (+ (* im im) (* re re))))) (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/4 binary64)) (fma.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) #s(literal 120 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im))) #s(literal -1/720 binary64)) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) 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) (*.f64 im im)) (*.f64 im im))) #s(literal 1/720 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im))))))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (fma.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/16 binary64) (pow.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)))) #s(literal 1 binary64))))

eval33.0ms (1%)

Memory
31.4MiB live, 75.8MiB allocated; 5ms collecting garbage
Compiler

Compiled 8 722 to 2 455 computations (71.9% saved)

prune16.0ms (0.5%)

Memory
-9.9MiB live, 35.7MiB allocated; 4ms collecting garbage
Pruning

13 alts after pruning (2 fresh and 11 done)

PrunedKeptTotal
New3402342
Fresh000
Picked123
Done099
Total34113354
Accuracy
99.7%
Counts
354 → 13
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓51.4%
(/.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.0%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓0.0%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
✓10.7%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re))) (log.f64 #s(literal 1/10 binary64)))
✓99.0%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓51.3%
(/.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)))
✓10.7%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
✓98.0%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
0.0%
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (fma.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)))))
0.0%
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.f64 (fma.f64 #s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 re re)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
Compiler

Compiled 632 to 423 computations (33.1% saved)

regimes56.0ms (1.7%)

Memory
-15.7MiB live, 82.0MiB allocated; 42ms collecting garbage
Counts
16 → 1
Calls
Call 1
Inputs
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) 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 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (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 (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)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.f64 (fma.f64 #s(approx (- (/ (* 1/6 (* re re)) (* (* (* (* im im) im) (* (* im im) im)) (log 10))) (/ 1/4 (* (* (* (* im im) im) im) (log 10)))) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/6 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 re re)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (-.f64 (*.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 (*.f64 im im) 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 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.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) (fma.f64 (*.f64 (pow.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 3 binary64)) (/.f64 #s(literal 120 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 (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (neg (/ (neg (log (neg im))) (log 10))) (+ (* (/ (* (* re re) (* re re)) (* (* (* im im) (* im im)) (log 10))) -1/4) (+ (* (* (pow (/ (* re re) (* im im)) 3) (/ 120 (log 10))) 1/720) (/ (* 1/2 (* re re)) (* (* im im) (log 10)))))) (/.f64 (fma.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64))) (*.f64 im im) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)))))
Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
Calls

8 calls:

22.0ms
re
7.0ms
(*.f64 re re)
5.0ms
im
4.0ms
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
4.0ms
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
Results
AccuracySegmentsBranch
99.0%1(*.f64 im im)
99.0%1(*.f64 re re)
99.0%1(+.f64 (*.f64 re re) (*.f64 im im))
99.0%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
99.0%1(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
99.0%1(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
99.0%1re
99.0%1im
Compiler

Compiled 34 to 38 computations (-11.8% saved)

regimes29.0ms (0.8%)

Memory
24.4MiB live, 70.0MiB allocated; 3ms collecting garbage
Counts
11 → 1
Calls
Call 1
Inputs
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) 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 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (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 (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 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
Calls

8 calls:

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

Compiled 34 to 38 computations (-11.8% saved)

regimes18.0ms (0.5%)

Memory
-3.5MiB live, 42.9MiB allocated; 4ms collecting garbage
Accuracy

Total -62.7b remaining (-4933.1%)

Threshold costs -62.7b (-4933.1%)

Counts
5 → 1
Calls
Call 1
Inputs
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) 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 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) re))) (log.f64 #s(literal 1/10 binary64)))
Outputs
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
Calls

8 calls:

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

Compiled 34 to 38 computations (-11.8% saved)

derivations71.0ms (2.1%)

Memory
-34.0MiB live, 64.4MiB allocated; 9ms collecting garbage
Stop Event
1×fuel
Compiler

Compiled 24 to 18 computations (25% saved)

preprocess63.0ms (1.9%)

Memory
29.9MiB live, 76.2MiB allocated; 4ms collecting garbage
Compiler

Compiled 214 to 208 computations (2.8% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...