math.log10 on complex, real part

Time bar (total: 4.5s)

start0.0ms (0%)

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

analyze530.0ms (11.8%)

Memory
-132.0MiB live, 223.5MiB allocated; 720ms 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)

sample1.2s (25.9%)

Memory
33.6MiB live, 1 785.4MiB allocated; 268ms collecting garbage
Samples
811.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 538.0ms
ival-hypot: 237.0ms (44% of total)
ival-log: 230.0ms (42.7% of total)
ival-div: 61.0ms (11.3% of total)
exact: 6.0ms (1.1% of total)
adjust: 3.0ms (0.6% of total)
ival-assert: 3.0ms (0.6% of total)
Bogosity

explain215.0ms (4.8%)

Memory
-1.3MiB live, 379.1MiB allocated; 30ms collecting garbage
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1330-1(-2.8870737643875894e-160 -1.677627787242784e-293)(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
00-0-(log.f64 #s(literal 10 binary64))
00-0-(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
00-0-(*.f64 re re)
00-0-im
00-0-(+.f64 (*.f64 re re) (*.f64 im im))
00-0-re
00-0-(*.f64 im im)
00-0-#s(literal 10 binary64)
00-0-(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
Explanations
Click to see full explanations table
OperatorSubexpressionExplanationCount
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))oflow-rescue1200
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow120
↳(*.f64 re re)overflow78
↳(*.f64 im im)overflow62
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue120
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow12
↳(*.f64 re re)underflow47
↳(*.f64 im im)underflow66
Confusion
Predicted +Predicted -
+1321
-0123
Precision
1.0
Recall
0.9924812030075187
Confusion?
Predicted +Predicted MaybePredicted -
+13201
-00123
Precision?
1.0
Recall?
0.9924812030075187
Freqs
test
numberfreq
0124
1132
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
79.0ms512×0valid
Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 61.0ms
ival-hypot: 32.0ms (52.3% of total)
ival-log: 12.0ms (19.6% of total)
ival-mult: 9.0ms (14.7% of total)
ival-div: 4.0ms (6.5% of total)
ival-add: 2.0ms (3.3% of total)
adjust: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

preprocess36.0ms (0.8%)

Memory
-3.5MiB live, 42.8MiB allocated; 4ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02874
16074
211074
313574
417374
01012
01712
12812
26712
312412
416112
01617
Stop Event
1×iter limit
1×saturated
1×iter limit
1×saturated
Calls
Call 1
Inputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
Outputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))
Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 12 to 10 computations (16.7% saved)

eval0.0ms (0%)

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

Compiled 0 to 2 computations (-∞% saved)

prune0.0ms (0%)

Memory
1.4MiB live, 1.4MiB allocated; 0ms collecting garbage
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶49.4%
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
Compiler

Compiled 12 to 10 computations (16.7% saved)

series18.0ms (0.4%)

Memory
4.3MiB live, 49.3MiB allocated; 5ms 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
6.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
@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
re
@0
((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) re (* im im) im (log 10) 10)
3.0ms
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)

rewrite255.0ms (5.7%)

Memory
-0.6MiB live, 394.5MiB allocated; 143ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

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

eval32.0ms (0.7%)

Memory
7.6MiB live, 108.3MiB allocated; 11ms collecting garbage
Compiler

Compiled 4 158 to 936 computations (77.5% saved)

prune9.0ms (0.2%)

Memory
-18.9MiB live, 27.4MiB allocated; 4ms collecting garbage
Pruning

5 alts after pruning (5 fresh and 0 done)

PrunedKeptTotal
New2125217
Fresh000
Picked101
Done000
Total2135218
Accuracy
99.7%
Counts
218 → 5
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶49.4%
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶99.0%
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
▶99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶98.2%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶91.3%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))) (log.f64 #s(literal 10 binary64)))
Compiler

Compiled 130 to 106 computations (18.5% saved)

series140.0ms (3.1%)

Memory
-4.1MiB live, 182.3MiB allocated; 24ms collecting garbage
Counts
28 → 258
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 (*.f64 #s(literal 1/2 binary64) (log.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))))
#s(literal 1/2 binary64)
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
(*.f64 re re)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(/.f64 #s(literal 1/2 binary64) im)
(/.f64 (*.f64 re re) im)
(log.f64 im)
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 (hypot.f64 im re)))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* 1/2 (/ (log (pow im 2)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (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/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow im 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* (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 (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow im 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (log im)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (* re re) im) #s(hole binary64 (/ (pow re 2) im)))
#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 (/ (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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* 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 (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))))
#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 (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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* 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 (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))))
#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 (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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* 1/2 (/ (log (pow re 2)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow re 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* (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 (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow re 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) (pow im 2))))
#s(approx (/ 1/2 im) #s(hole binary64 (/ 1/2 im)))
#s(approx (log im) #s(hole binary64 (log 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 (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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* 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 (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log 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 (* 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 (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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (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 (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* 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 (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log 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 (* -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
65.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))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log 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)
33.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))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log 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)
14.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))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log 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)
11.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))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log 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)
7.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))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log 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)

rewrite264.0ms (5.9%)

Memory
28.6MiB live, 387.2MiB allocated; 129ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

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

eval57.0ms (1.3%)

Memory
43.2MiB live, 124.6MiB allocated; 33ms collecting garbage
Compiler

Compiled 7 943 to 1 197 computations (84.9% saved)

prune38.0ms (0.9%)

Memory
-10.9MiB live, 54.3MiB allocated; 37ms collecting garbage
Pruning

11 alts after pruning (8 fresh and 3 done)

PrunedKeptTotal
New2948302
Fresh000
Picked235
Done000
Total29611307
Accuracy
99.7%
Counts
307 → 11
Alt Table
Click to see full alt table
StatusAccuracyProgram
17.4%
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (log.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64)))
▶49.4%
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓49.4%
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
98.1%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓98.2%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶98.7%
(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
▶67.2%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/8 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
47.8%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (*.f64 im im) (log.f64 im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
▶50.7%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (*.f64 re re))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶3.8%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
Compiler

Compiled 533 to 360 computations (32.5% saved)

series160.0ms (3.6%)

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

6 calls:

TimeVariablePointExpression
32.0ms
re
@inf
((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (* re re)) (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (pow im -2) -2 (/ (log im) (* re re)) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (/ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) 1/8 (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))
30.0ms
re
@-inf
((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (* re re)) (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (pow im -2) -2 (/ (log im) (* re re)) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (/ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) 1/8 (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))
28.0ms
re
@0
((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (* re re)) (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (pow im -2) -2 (/ (log im) (* re re)) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (/ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) 1/8 (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))
19.0ms
im
@-inf
((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (* re re)) (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (pow im -2) -2 (/ (log im) (* re re)) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (/ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) 1/8 (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))
19.0ms
im
@inf
((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (* re re)) (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (pow im -2) -2 (/ (log im) (* re re)) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (/ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) 1/8 (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))

rewrite248.0ms (5.5%)

Memory
-2.1MiB live, 390.5MiB allocated; 88ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

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

eval74.0ms (1.7%)

Memory
11.0MiB live, 152.5MiB allocated; 15ms collecting garbage
Compiler

Compiled 28 774 to 2 854 computations (90.1% saved)

prune44.0ms (1%)

Memory
7.0MiB live, 98.3MiB allocated; 8ms collecting garbage
Pruning

30 alts after pruning (24 fresh and 6 done)

PrunedKeptTotal
New60322625
Fresh123
Picked235
Done033
Total60630636
Accuracy
99.8%
Counts
636 → 30
Alt Table
Click to see full alt table
StatusAccuracyProgram
17.4%
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (log.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64)))
✓49.4%
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓49.4%
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶98.6%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)))) (log.f64 #s(literal 1/10 binary64)))
▶98.1%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
50.6%
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
3.7%
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im))))) (log.f64 #s(literal 1/10 binary64)))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓98.2%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
✓98.7%
(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
59.1%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/8 binary64) (pow.f64 (pow.f64 (log.f64 im) #s(literal 3/2 binary64)) #s(literal 2 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
58.4%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/8 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
67.2%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/8 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (log.f64 #s(literal 10 binary64)))
67.2%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/8 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 6 binary64))) (-.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/8 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
▶98.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
47.8%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (/.f64 (fma.f64 (*.f64 im im) (log.f64 im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
3.7%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im)))) (log.f64 #s(literal 10 binary64)))
3.5%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re)) im))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (pow.f64 (pow.f64 re #s(literal -1 binary64)) #s(literal -2 binary64)))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (*.f64 re re))) (pow.f64 (pow.f64 re #s(literal -1 binary64)) #s(literal -2 binary64))))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 re #s(literal -1 binary64)) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64)))
50.7%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (*.f64 re re))) (*.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
▶3.0%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
3.5%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im)))) (log.f64 #s(literal 10 binary64)))
3.8%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓3.8%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
▶52.1%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re))) (log.f64 #s(literal 10 binary64)))
20.7%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (/.f64 (fma.f64 (*.f64 im im) (/.f64 (/.f64 (log.f64 im) re) re) #s(literal 1/2 binary64)) (*.f64 im im))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (/.f64 (*.f64 #s(literal 1 binary64) (log.f64 im)) (*.f64 re re))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
Compiler

Compiled 2 320 to 1 453 computations (37.4% saved)

series116.0ms (2.6%)

Memory
-35.0MiB live, 206.4MiB allocated; 43ms collecting garbage
Counts
51 → 266
Calls
Call 1
Inputs
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im))))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im))
(fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)
re
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(/.f64 re im)
im
#s(literal 1/2 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (*.f64 re re) (*.f64 im im))
(*.f64 re re)
(*.f64 im im)
(log.f64 #s(literal 10 binary64))
#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 (log.f64 #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)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re))
(*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re)
(*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re)
(fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re))
(pow.f64 im #s(literal -2 binary64))
#s(literal -2 binary64)
(/.f64 (/.f64 (log.f64 im) re) re)
(/.f64 (log.f64 im) re)
(log.f64 im)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im))))))
(/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))
(pow.f64 (log.f64 im) #s(literal 3 binary64))
#s(literal 3 binary64)
(+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im))))
(pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im)))
(/.f64 #s(literal 1/2 binary64) im)
(*.f64 re (/.f64 re im))
#s(literal 2 binary64)
(-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))
(pow.f64 (log.f64 im) #s(literal 2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im))
Outputs
#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 (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 im))
#s(approx (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx re #s(hole binary64 re))
#s(approx (* (/ re im) 1/2) #s(hole binary64 (* 1/2 (/ re im))))
#s(approx (/ re im) #s(hole binary64 (/ re 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 (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (log im)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* (/ (* re re) (* im im)) 1/2) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (/ (* re re) (* im im)) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (log im)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (/ (log im) re)))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (/ (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) re)))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (/ (log im) (pow re 2))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (/ (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (pow re 2))))
#s(approx (/ (/ (log im) re) re) #s(hole binary64 (/ (log im) (pow re 2))))
#s(approx (/ (log im) re) #s(hole binary64 (/ (log im) re)))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (log im)))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (pow (log im) 3)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (+ (* 1/8 (/ (pow re 6) (pow im 6))) (pow (log im) 3))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (pow (log im) 2)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log im)) (pow im 2))) (pow (log im) 2))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (+ (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ (log im) (pow im 2))))) (pow (log im) 2))))
#s(approx (pow (* (/ 1/2 im) (* re (/ re im))) 2) #s(hole binary64 (* 1/4 (/ (pow re 4) (pow im 4)))))
#s(approx (* (/ 1/2 im) (* re (/ re im))) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (* re (/ re im)) #s(hole binary64 (/ (pow re 2) im)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (pow (log im) 2)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log im)) (pow im 2))) (pow (log im) 2))))
#s(approx (* (* (/ 1/2 im) (* re (/ re im))) (log im)) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log im)) (pow im 2)))))
#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 (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (* 1/2 (/ (pow re 2) im))))
#s(approx (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* 1/2 (/ re (pow im 2)))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* re (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (/ 1/2 (pow im 2))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2)))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* (pow re 2) (- (+ (* -1 (/ (+ (* -2 (* (pow im 2) (pow (log im) 2))) (* 2 (* (pow im 2) (pow (log im) 2)))) (pow re 4))) (* 1/2 (/ 1 (pow im 2)))) (* -1 (/ (log im) (pow re 2)))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* (pow re 2) (- (+ (* -2 (/ (* (pow im 2) (* (log im) (+ (* -2 (* (pow im 2) (pow (log im) 2))) (* 2 (* (pow im 2) (pow (log im) 2)))))) (pow re 6))) (* 1/2 (/ 1 (pow im 2)))) (+ (* -2 (/ (* (pow im 2) (pow (log im) 2)) (pow re 4))) (+ (* -1 (/ (log im) (pow re 2))) (* 2 (/ (* (pow im 2) (pow (log im) 2)) (pow re 4)))))))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (* 1/8 (/ (pow re 6) (pow im 6)))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (* (pow re 6) (+ (* 1/8 (/ 1 (pow im 6))) (/ (pow (log im) 3) (pow re 6))))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (* 1/4 (/ (pow re 4) (pow im 4)))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (* (pow re 4) (+ (* -1/2 (/ (log im) (* (pow im 2) (pow re 2)))) (* 1/4 (/ 1 (pow im 4)))))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (* (pow re 4) (- (+ (* 1/4 (/ 1 (pow im 4))) (/ (pow (log im) 2) (pow re 4))) (* 1/2 (/ (log im) (* (pow im 2) (pow re 2))))))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (* -1/2 (/ (* (pow re 2) (log im)) (pow im 2)))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (* (pow re 2) (- (/ (pow (log im) 2) (pow re 2)) (* 1/2 (/ (log im) (pow im 2)))))))
#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 (* -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 (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* -1 (* re (- (* -1 (/ (log im) (pow re 2))) (* 1/2 (/ 1 (pow im 2))))))))
#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 (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)))
#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 (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) (pow im 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) (pow im 2))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (/ (+ (* 1/2 re) (/ (* (pow im 2) (log im)) re)) (pow im 2))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (/ (+ 1/2 (/ (* (pow im 2) (log im)) (pow re 2))) (pow im 2))))
#s(approx (pow im -2) #s(hole binary64 (/ 1 (pow im 2))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) (pow im 2))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -2 (/ (pow (log im) 2) (pow re 2))) (* 2 (/ (pow (log im) 2) (pow re 2)))))) (* -1 (log im))))) (pow im 2))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (- (* (pow im 2) (- (* -2 (/ (* (pow im 2) (* (log im) (+ (* -2 (/ (pow (log im) 2) (pow re 2))) (* 2 (/ (pow (log im) 2) (pow re 2)))))) (pow re 2))) (+ (* -2 (/ (pow (log im) 2) (pow re 2))) (* 2 (/ (pow (log im) 2) (pow re 2)))))) (* -1 (log im))))) (pow im 2))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (/ (+ (* 1/8 (pow re 6)) (* (pow im 6) (pow (log im) 3))) (pow im 6))))
#s(approx (pow (log im) 3) #s(hole binary64 (pow (log im) 3)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (/ (+ (* -1/2 (* (pow im 2) (* (pow re 2) (log im)))) (* 1/4 (pow re 4))) (pow im 4))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (/ (+ (* 1/4 (pow re 4)) (* (pow im 2) (- (* (pow im 2) (pow (log im) 2)) (* 1/2 (* (pow re 2) (log im)))))) (pow im 4))))
#s(approx (/ 1/2 im) #s(hole binary64 (/ 1/2 im)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (/ (- (* (pow im 2) (pow (log im) 2)) (* 1/2 (* (pow re 2) (log im)))) (pow im 2))))
#s(approx (pow (log im) 2) #s(hole binary64 (pow (log im) 2)))
#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 (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (* im (+ 1 (* 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 (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* -1 (/ (log (/ 1 im)) re))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) re)) (* 1/2 (/ re (pow im 2))))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (pow re 2)))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (pow re 2))) (* 1/2 (/ 1 (pow im 2))))))
#s(approx (/ (/ (log im) re) re) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (pow re 2)))))
#s(approx (/ (log im) re) #s(hole binary64 (* -1 (/ (log (/ 1 im)) re))))
#s(approx (log im) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (- (+ (* -1 (log (/ 1 im))) (* -1 (/ (+ (* -1/4 (/ (pow re 4) (log (/ 1 im)))) (* 1/4 (/ (pow re 4) (log (/ 1 im))))) (pow im 4)))) (* -1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (- (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (log (/ 1 im)))) (* 1/4 (/ (pow re 4) (log (/ 1 im)))))) (* (pow im 6) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log (/ 1 im))))) (* 1/4 (/ (pow re 4) (* (pow im 4) (log (/ 1 im))))))))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (* -1 (pow (log (/ 1 im)) 3))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (+ (* -1 (pow (log (/ 1 im)) 3)) (* 1/8 (/ (pow re 6) (pow im 6))))))
#s(approx (pow (log im) 3) #s(hole binary64 (* -1 (pow (log (/ 1 im)) 3))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (pow (log (/ 1 im)) 2)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (pow (log (/ 1 im)) 2))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (- (+ (* 1/4 (/ (pow re 4) (pow im 4))) (pow (log (/ 1 im)) 2)) (* -1/2 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (pow (log (/ 1 im)) 2)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (pow (log (/ 1 im)) 2))))
#s(approx (pow (log im) 2) #s(hole binary64 (pow (log (/ 1 im)) 2)))
#s(approx (* (* (/ 1/2 im) (* re (/ re im))) (log im)) #s(hole binary64 (* -1/2 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2)))))
#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))))))))))
#s(approx (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))))
#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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2))))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (pow im 2))) (* (pow re 2) (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2)))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* re (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (+ (* 1/2 (/ re (pow im 2))) (* re (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2)))))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2)))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log -1) (pow re 2))))))
#s(approx (/ (/ (log im) re) re) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow re 2))))
#s(approx (/ (log im) re) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) re)))
#s(approx (log im) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 im))) (* -1 (/ (+ (* -1/4 (/ (pow re 4) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/4 (/ (pow re 4) (+ (log -1) (* -1 (log (/ -1 im))))))) (pow im 4))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 im))) (* -1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/4 (/ (pow re 4) (+ (log -1) (* -1 (log (/ -1 im)))))))) (* (pow im 6) (+ (log -1) (* -1 (log (/ -1 im))))))))) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (+ (log -1) (* -1 (log (/ -1 im))))))) (* 1/4 (/ (pow re 4) (* (pow im 4) (+ (log -1) (* -1 (log (/ -1 im))))))))))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (+ (* 1/8 (/ (pow re 6) (pow im 6))) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3))))
#s(approx (pow (log im) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 im))))) (pow im 2))) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (- (+ (* 1/4 (/ (pow re 4) (pow im 4))) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)) (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 im))))) (pow im 2))))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 im))))) (pow im 2))) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2))))
#s(approx (pow (log im) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))
#s(approx (* (* (/ 1/2 im) (* re (/ re im))) (log im)) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 im))))) (pow im 2)))))
Calls

6 calls:

TimeVariablePointExpression
24.0ms
re
@inf
((/ (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))) (+ (* re (* (/ re im) 1/2)) im) re (* (/ re im) 1/2) (/ re im) im 1/2 (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (log 10) 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))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (pow im -2) -2 (/ (/ (log im) re) re) (/ (log im) re) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (* re (/ re im)) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))
17.0ms
im
@inf
((/ (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))) (+ (* re (* (/ re im) 1/2)) im) re (* (/ re im) 1/2) (/ re im) im 1/2 (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (log 10) 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))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (pow im -2) -2 (/ (/ (log im) re) re) (/ (log im) re) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (* re (/ re im)) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))
16.0ms
re
@0
((/ (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))) (+ (* re (* (/ re im) 1/2)) im) re (* (/ re im) 1/2) (/ re im) im 1/2 (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (log 10) 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))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (pow im -2) -2 (/ (/ (log im) re) re) (/ (log im) re) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (* re (/ re im)) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))
16.0ms
re
@-inf
((/ (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))) (+ (* re (* (/ re im) 1/2)) im) re (* (/ re im) 1/2) (/ re im) im 1/2 (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (log 10) 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))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (pow im -2) -2 (/ (/ (log im) re) re) (/ (log im) re) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (* re (/ re im)) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))
16.0ms
im
@0
((/ (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))) (+ (* re (* (/ re im) 1/2)) im) re (* (/ re im) 1/2) (/ re im) im 1/2 (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (log 10) 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))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (pow im -2) -2 (/ (/ (log im) re) re) (/ (log im) re) (log im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow (log im) 3) 3 (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (* re (/ re im)) 2 (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))

rewrite229.0ms (5.1%)

Memory
54.2MiB live, 285.9MiB allocated; 20ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
09409922
010038985
150538295
085917239
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
317 → 503
Calls
Call 1
Inputs
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im))))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im))
(fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)
re
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(/.f64 re im)
im
#s(literal 1/2 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64))
(/.f64 (*.f64 re re) (*.f64 im im))
(*.f64 re re)
(*.f64 im im)
(log.f64 #s(literal 10 binary64))
#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 (log.f64 #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)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re))
(*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re)
(*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re)
(fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re))
(pow.f64 im #s(literal -2 binary64))
#s(literal -2 binary64)
(/.f64 (/.f64 (log.f64 im) re) re)
(/.f64 (log.f64 im) re)
(log.f64 im)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im))))))
(/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))
(pow.f64 (log.f64 im) #s(literal 3 binary64))
#s(literal 3 binary64)
(+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im))))
(pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im)))
(/.f64 #s(literal 1/2 binary64) im)
(*.f64 re (/.f64 re im))
#s(literal 2 binary64)
(-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))
(pow.f64 (log.f64 im) #s(literal 2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im))
#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 (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 im))
#s(approx (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx re #s(hole binary64 re))
#s(approx (* (/ re im) 1/2) #s(hole binary64 (* 1/2 (/ re im))))
#s(approx (/ re im) #s(hole binary64 (/ re 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 (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (log im)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* (/ (* re re) (* im im)) 1/2) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (/ (* re re) (* im im)) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (log im)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (/ (log im) re)))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (/ (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) re)))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (/ (log im) (pow re 2))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (/ (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (pow re 2))))
#s(approx (/ (/ (log im) re) re) #s(hole binary64 (/ (log im) (pow re 2))))
#s(approx (/ (log im) re) #s(hole binary64 (/ (log im) re)))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (log im)))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (pow (log im) 3)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (+ (* 1/8 (/ (pow re 6) (pow im 6))) (pow (log im) 3))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (pow (log im) 2)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log im)) (pow im 2))) (pow (log im) 2))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (+ (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ (log im) (pow im 2))))) (pow (log im) 2))))
#s(approx (pow (* (/ 1/2 im) (* re (/ re im))) 2) #s(hole binary64 (* 1/4 (/ (pow re 4) (pow im 4)))))
#s(approx (* (/ 1/2 im) (* re (/ re im))) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (* re (/ re im)) #s(hole binary64 (/ (pow re 2) im)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (pow (log im) 2)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (log im)) (pow im 2))) (pow (log im) 2))))
#s(approx (* (* (/ 1/2 im) (* re (/ re im))) (log im)) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log im)) (pow im 2)))))
#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 (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (* 1/2 (/ (pow re 2) im))))
#s(approx (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* 1/2 (/ re (pow im 2)))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* re (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (/ 1/2 (pow im 2))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2)))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log im) (pow re 2))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* (pow re 2) (- (+ (* -1 (/ (+ (* -2 (* (pow im 2) (pow (log im) 2))) (* 2 (* (pow im 2) (pow (log im) 2)))) (pow re 4))) (* 1/2 (/ 1 (pow im 2)))) (* -1 (/ (log im) (pow re 2)))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* (pow re 2) (- (+ (* -2 (/ (* (pow im 2) (* (log im) (+ (* -2 (* (pow im 2) (pow (log im) 2))) (* 2 (* (pow im 2) (pow (log im) 2)))))) (pow re 6))) (* 1/2 (/ 1 (pow im 2)))) (+ (* -2 (/ (* (pow im 2) (pow (log im) 2)) (pow re 4))) (+ (* -1 (/ (log im) (pow re 2))) (* 2 (/ (* (pow im 2) (pow (log im) 2)) (pow re 4)))))))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (* 1/8 (/ (pow re 6) (pow im 6)))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (* (pow re 6) (+ (* 1/8 (/ 1 (pow im 6))) (/ (pow (log im) 3) (pow re 6))))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (* 1/4 (/ (pow re 4) (pow im 4)))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (* (pow re 4) (+ (* -1/2 (/ (log im) (* (pow im 2) (pow re 2)))) (* 1/4 (/ 1 (pow im 4)))))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (* (pow re 4) (- (+ (* 1/4 (/ 1 (pow im 4))) (/ (pow (log im) 2) (pow re 4))) (* 1/2 (/ (log im) (* (pow im 2) (pow re 2))))))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (* -1/2 (/ (* (pow re 2) (log im)) (pow im 2)))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (* (pow re 2) (- (/ (pow (log im) 2) (pow re 2)) (* 1/2 (/ (log im) (pow im 2)))))))
#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 (* -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 (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* -1 (* re (- (* -1 (/ (log im) (pow re 2))) (* 1/2 (/ 1 (pow im 2))))))))
#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 (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)))
#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 (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) (pow im 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) (pow im 2))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (/ (+ (* 1/2 re) (/ (* (pow im 2) (log im)) re)) (pow im 2))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (/ (+ 1/2 (/ (* (pow im 2) (log im)) (pow re 2))) (pow im 2))))
#s(approx (pow im -2) #s(hole binary64 (/ 1 (pow im 2))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (log im))) (pow im 2))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -2 (/ (pow (log im) 2) (pow re 2))) (* 2 (/ (pow (log im) 2) (pow re 2)))))) (* -1 (log im))))) (pow im 2))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (/ (+ (* 1/2 (pow re 2)) (* (pow im 2) (- (* (pow im 2) (- (* -2 (/ (* (pow im 2) (* (log im) (+ (* -2 (/ (pow (log im) 2) (pow re 2))) (* 2 (/ (pow (log im) 2) (pow re 2)))))) (pow re 2))) (+ (* -2 (/ (pow (log im) 2) (pow re 2))) (* 2 (/ (pow (log im) 2) (pow re 2)))))) (* -1 (log im))))) (pow im 2))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (/ (+ (* 1/8 (pow re 6)) (* (pow im 6) (pow (log im) 3))) (pow im 6))))
#s(approx (pow (log im) 3) #s(hole binary64 (pow (log im) 3)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (/ (+ (* -1/2 (* (pow im 2) (* (pow re 2) (log im)))) (* 1/4 (pow re 4))) (pow im 4))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (/ (+ (* 1/4 (pow re 4)) (* (pow im 2) (- (* (pow im 2) (pow (log im) 2)) (* 1/2 (* (pow re 2) (log im)))))) (pow im 4))))
#s(approx (/ 1/2 im) #s(hole binary64 (/ 1/2 im)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (/ (- (* (pow im 2) (pow (log im) 2)) (* 1/2 (* (pow re 2) (log im)))) (pow im 2))))
#s(approx (pow (log im) 2) #s(hole binary64 (pow (log im) 2)))
#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 (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (* im (+ 1 (* 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 (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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* -1 (/ (log (/ 1 im)) re))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) re)) (* 1/2 (/ re (pow im 2))))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (pow re 2)))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (pow re 2))) (* 1/2 (/ 1 (pow im 2))))))
#s(approx (/ (/ (log im) re) re) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (pow re 2)))))
#s(approx (/ (log im) re) #s(hole binary64 (* -1 (/ (log (/ 1 im)) re))))
#s(approx (log im) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (- (+ (* -1 (log (/ 1 im))) (* -1 (/ (+ (* -1/4 (/ (pow re 4) (log (/ 1 im)))) (* 1/4 (/ (pow re 4) (log (/ 1 im))))) (pow im 4)))) (* -1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (- (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (log (/ 1 im)))) (* 1/4 (/ (pow re 4) (log (/ 1 im)))))) (* (pow im 6) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log (/ 1 im))))) (* 1/4 (/ (pow re 4) (* (pow im 4) (log (/ 1 im))))))))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (* -1 (pow (log (/ 1 im)) 3))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (+ (* -1 (pow (log (/ 1 im)) 3)) (* 1/8 (/ (pow re 6) (pow im 6))))))
#s(approx (pow (log im) 3) #s(hole binary64 (* -1 (pow (log (/ 1 im)) 3))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (pow (log (/ 1 im)) 2)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (pow (log (/ 1 im)) 2))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (- (+ (* 1/4 (/ (pow re 4) (pow im 4))) (pow (log (/ 1 im)) 2)) (* -1/2 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (pow (log (/ 1 im)) 2)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (pow (log (/ 1 im)) 2))))
#s(approx (pow (log im) 2) #s(hole binary64 (pow (log (/ 1 im)) 2)))
#s(approx (* (* (/ 1/2 im) (* re (/ re im))) (log im)) #s(hole binary64 (* -1/2 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2)))))
#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))))))))))
#s(approx (+ (* re (* (/ re im) 1/2)) im) #s(hole binary64 (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))))
#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 (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2))))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (pow im 2))) (* (pow re 2) (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2)))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (* re (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) #s(hole binary64 (+ (* 1/2 (/ re (pow im 2))) (* re (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2)))))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (/ (log -1) (pow re 2)))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (pow re 2))) (+ (* 1/2 (/ 1 (pow im 2))) (/ (log -1) (pow re 2))))))
#s(approx (/ (/ (log im) re) re) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (pow re 2))))
#s(approx (/ (log im) re) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) re)))
#s(approx (log im) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 im))) (* -1 (/ (+ (* -1/4 (/ (pow re 4) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/4 (/ (pow re 4) (+ (log -1) (* -1 (log (/ -1 im))))))) (pow im 4))))) (* -1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) #s(hole binary64 (- (+ (log -1) (+ (* -1 (log (/ -1 im))) (* -1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/4 (/ (pow re 4) (+ (log -1) (* -1 (log (/ -1 im)))))))) (* (pow im 6) (+ (log -1) (* -1 (log (/ -1 im))))))))) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (+ (log -1) (* -1 (log (/ -1 im))))))) (* 1/4 (/ (pow re 4) (* (pow im 4) (+ (log -1) (* -1 (log (/ -1 im))))))))))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) #s(hole binary64 (+ (* 1/8 (/ (pow re 6) (pow im 6))) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3))))
#s(approx (pow (log im) 3) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 3)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 im))))) (pow im 2))) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) #s(hole binary64 (- (+ (* 1/4 (/ (pow re 4) (pow im 4))) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)) (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 im))))) (pow im 2))))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) #s(hole binary64 (+ (* -1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 im))))) (pow im 2))) (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2))))
#s(approx (pow (log im) 2) #s(hole binary64 (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2)))
#s(approx (* (* (/ 1/2 im) (* re (/ re im))) (log im)) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (+ (log -1) (* -1 (log (/ -1 im))))) (pow im 2)))))
Outputs
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im)))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im))))
(log.f64 (pow.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im)) #s(literal -1 binary64)))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im)))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im))
(/.f64 (-.f64 (*.f64 im im) (pow.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) #s(literal 2 binary64))) (-.f64 im (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))
(/.f64 (-.f64 (pow.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) im))
(/.f64 (+.f64 (pow.f64 im #s(literal 3 binary64)) (*.f64 (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 3 binary64)) #s(literal 1/8 binary64))) (fma.f64 im im (-.f64 (pow.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (*.f64 im (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 im #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (-.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) im))))
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
(fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im)
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)
(fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)
(-.f64 im (*.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re)))
(+.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) im)
(+.f64 im (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))
re
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(/.f64 (neg.f64 re) (neg.f64 im))
(/.f64 re im)
im
#s(literal 1/2 binary64)
(neg.f64 (log.f64 #s(literal 10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) #s(literal 1 binary64)) (pow.f64 (/.f64 re im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1 binary64)) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64)) (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 1 binary64)))
(*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im))
(*.f64 (*.f64 (/.f64 re im) re) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 (/.f64 re im) re))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(/.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re)) im)
(/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im))
(/.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) im)
(/.f64 #s(literal 1 binary64) (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(*.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 re re)) (neg.f64 (*.f64 im im)))
(/.f64 (*.f64 (/.f64 re im) re) 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))))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 re re)
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 re) #s(literal 2 binary64))))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 im im)
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(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))))
(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))) 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 (pow.f64 #s(approx (sqrt (+ (* im im) (* re re))) im) #s(literal -1 binary64)))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))
#s(approx (sqrt (+ (* im im) (* re re))) im)
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re)))
(*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re)
(*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re))
(*.f64 (*.f64 re re) (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)))
(*.f64 re (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re) (*.f64 (/.f64 (/.f64 (log.f64 im) re) re) (*.f64 re re)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (/.f64 (/.f64 (log.f64 im) re) re)))
(+.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 (/.f64 (/.f64 (log.f64 im) re) re) (*.f64 re re)))
(+.f64 (*.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 (*.f64 re re) (/.f64 (/.f64 (log.f64 im) re) re)))
(*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re)
(*.f64 re (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re (*.f64 (/.f64 (/.f64 (log.f64 im) re) re) re))
(fma.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re (/.f64 (/.f64 (log.f64 im) re) re)))
(+.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) (*.f64 (/.f64 (/.f64 (log.f64 im) re) re) re))
(+.f64 (*.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 re (/.f64 (/.f64 (log.f64 im) re) re)))
(/.f64 (-.f64 (pow.f64 (/.f64 (/.f64 (log.f64 im) re) re) #s(literal 2 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 2 binary64))) (-.f64 (/.f64 (/.f64 (log.f64 im) re) re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))))
(/.f64 (-.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 2 binary64)) (pow.f64 (/.f64 (/.f64 (log.f64 im) re) re) #s(literal 2 binary64))) (-.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (/.f64 (log.f64 im) re) re)))
(/.f64 (fma.f64 (pow.f64 im #s(literal -6 binary64)) #s(literal 1/8 binary64) (/.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))) (+.f64 (pow.f64 (/.f64 (/.f64 (log.f64 im) re) re) #s(literal 2 binary64)) (-.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 2 binary64)) (*.f64 (/.f64 (/.f64 (log.f64 im) re) re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))))))
(/.f64 (fma.f64 (pow.f64 im #s(literal -6 binary64)) #s(literal 1/8 binary64) (/.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))) (+.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 2 binary64)) (-.f64 (pow.f64 (/.f64 (/.f64 (log.f64 im) re) re) #s(literal 2 binary64)) (*.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (/.f64 (log.f64 im) re) re)))))
(fma.f64 (/.f64 (neg.f64 (log.f64 im)) (*.f64 re re)) #s(literal -1 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))
(fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re))
(fma.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (*.f64 re re)) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))
(fma.f64 #s(literal 1/2 binary64) (pow.f64 im #s(literal -2 binary64)) (/.f64 (/.f64 (log.f64 im) re) re))
(-.f64 (/.f64 (/.f64 (log.f64 im) re) re) (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal -2 binary64))))
(+.f64 (/.f64 (/.f64 (log.f64 im) re) re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))
(+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (/.f64 (log.f64 im) re) re))
(*.f64 (pow.f64 (fabs.f64 im) #s(literal -1 binary64)) (pow.f64 (fabs.f64 im) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) im) (/.f64 #s(literal -1 binary64) im))
(*.f64 (pow.f64 im #s(literal -1 binary64)) (pow.f64 im #s(literal -1 binary64)))
(pow.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal -1 binary64))
(pow.f64 im #s(literal -2 binary64))
(/.f64 #s(literal 1 binary64) (*.f64 im im))
(/.f64 #s(literal -1 binary64) (neg.f64 (*.f64 im im)))
(exp.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) #s(literal 2 binary64))))
(exp.f64 (neg.f64 (*.f64 (log.f64 im) #s(literal 2 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal -1 binary64)))
(exp.f64 (*.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(literal -2 binary64)
(*.f64 (/.f64 (neg.f64 (log.f64 im)) (*.f64 re re)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (*.f64 re re)))
(/.f64 (neg.f64 (/.f64 (log.f64 im) re)) (neg.f64 re))
(/.f64 (/.f64 (log.f64 im) re) re)
(/.f64 (neg.f64 (log.f64 im)) (neg.f64 (*.f64 re re)))
(/.f64 (log.f64 im) (*.f64 re re))
(neg.f64 (/.f64 (neg.f64 (log.f64 im)) (*.f64 re re)))
(*.f64 (/.f64 (neg.f64 (log.f64 im)) re) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) re))
(/.f64 (neg.f64 (log.f64 im)) (neg.f64 re))
(/.f64 (log.f64 im) re)
(neg.f64 (/.f64 (neg.f64 (log.f64 im)) re))
(*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(pow.f64 (log.f64 im) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1 binary64)))
(neg.f64 (neg.f64 (log.f64 im)))
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 1 binary64)))
(log.f64 im)
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (fma.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (fma.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (fma.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))))
(/.f64 (neg.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))))
(/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (fma.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))
(*.f64 (pow.f64 (log.f64 im) #s(literal 3/2 binary64)) (pow.f64 (log.f64 im) #s(literal 3/2 binary64)))
(*.f64 (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)) #s(literal -1 binary64))
(*.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 im))
(*.f64 #s(literal -1 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))
(*.f64 (log.f64 im) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(pow.f64 (exp.f64 (log.f64 (log.f64 im))) #s(literal 3 binary64))
(pow.f64 (pow.f64 (log.f64 im) #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 3/2 binary64))
(pow.f64 (log.f64 im) #s(literal 3 binary64))
(neg.f64 (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))))
(log.f64 (pow.f64 im (pow.f64 (log.f64 im) #s(literal 2 binary64))))
#s(literal 3 binary64)
(/.f64 (-.f64 (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 4 binary64)) (pow.f64 (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))) #s(literal 2 binary64))) (-.f64 (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 6 binary64)) (pow.f64 (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 4 binary64)) (-.f64 (pow.f64 (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))) #s(literal 2 binary64)) (*.f64 (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)))))))
(fma.f64 (exp.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (exp.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))
(fma.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))
(fma.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))
(fma.f64 (*.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/4 binary64)) (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))
(fma.f64 (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/4 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))
(fma.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))
(fma.f64 #s(literal 1/4 binary64) (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))
(-.f64 (fma.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)))
(+.f64 (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))
(+.f64 (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))) (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 2 binary64)))
(*.f64 (exp.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (exp.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
(*.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)) #s(literal 1/4 binary64))
(*.f64 (*.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/4 binary64)) (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 2 binary64)))
(*.f64 (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 #s(literal 1/4 binary64) (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 2 binary64)))
(pow.f64 (exp.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 2 binary64))))
(*.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) #s(literal 1 binary64)) (pow.f64 (/.f64 re im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1 binary64)) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64)) (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 1 binary64)))
(*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im))
(*.f64 (*.f64 (/.f64 re im) re) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 (/.f64 re im) re))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(/.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re)) im)
(/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im))
(/.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) im)
(/.f64 #s(literal 1 binary64) (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (pow.f64 im #s(literal -1 binary64)))
(/.f64 #s(literal -1/2 binary64) (neg.f64 im))
(/.f64 #s(literal 1/2 binary64) im)
(*.f64 (/.f64 re im) re)
(*.f64 re (/.f64 re im))
(/.f64 (neg.f64 (*.f64 re re)) (neg.f64 im))
(/.f64 (*.f64 re re) im)
#s(literal 2 binary64)
(/.f64 (-.f64 (pow.f64 (log.f64 im) #s(literal 4 binary64)) (pow.f64 (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)) #s(literal 2 binary64))) (fma.f64 (log.f64 im) (log.f64 im) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))
(/.f64 (-.f64 (pow.f64 (log.f64 im) #s(literal 6 binary64)) (pow.f64 (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 im) #s(literal 4 binary64)) (+.f64 (pow.f64 (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))))
(fma.f64 (exp.f64 (log.f64 (log.f64 im))) (exp.f64 (log.f64 (log.f64 im))) (*.f64 (neg.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) (log.f64 im)))
(fma.f64 (log.f64 im) (log.f64 im) (*.f64 (neg.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) (log.f64 im)))
(-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)))
(+.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (neg.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) (log.f64 im)))
(*.f64 (exp.f64 (log.f64 (log.f64 im))) (exp.f64 (log.f64 (log.f64 im))))
(*.f64 (log.f64 im) (log.f64 im))
(pow.f64 (exp.f64 (log.f64 (log.f64 im))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 im) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))))
(log.f64 (pow.f64 im (log.f64 im)))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 (*.f64 (/.f64 re im) re) (log.f64 im)))
(*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))
(*.f64 (log.f64 im) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(log.f64 (pow.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 (/.f64 re im) #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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (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 (fma.f64 (/.f64 (*.f64 re re) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (*.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal -2 binary64)) (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 (fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -4 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 re re)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64))))) (*.f64 re re) (*.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal -2 binary64)) (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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal -2 binary64)))) (*.f64 re re)) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 (fma.f64 (fma.f64 (pow.f64 im #s(literal -4 binary64)) #s(literal 1/4 binary64) (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 re re)) (pow.f64 im #s(literal 6 binary64)))) (*.f64 re re) (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal -2 binary64)))) (*.f64 re re)) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (*.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (*.f64 re re))) (*.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 im) #s(literal 1/2 binary64)) re im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 3 binary64))) #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 (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal -3 binary64)))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im))
#s(approx (+ (* re (* (/ re im) 1/2)) im) im)
#s(approx (+ (* re (* (/ re im) 1/2)) im) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im))
#s(approx re re)
#s(approx (* (/ re im) 1/2) (*.f64 (/.f64 re im) #s(literal 1/2 binary64)))
#s(approx (/ re im) (/.f64 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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (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 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 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 (fma.f64 (/.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (*.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))))) (*.f64 re re) (*.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (*.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (*.f64 re re))) (*.f64 re re) (log.f64 im)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (log.f64 im))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (* (/ 1/2 im) (* re (/ re im))) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
#s(approx (/ (* re re) (* im im)) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
#s(approx (* re re) (*.f64 re re))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (log.f64 im))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (/.f64 (log.f64 im) re))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)) re))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 (/.f64 (log.f64 im) re) re))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)) (*.f64 re re)))
#s(approx (/ (/ (log im) re) re) (/.f64 (/.f64 (log.f64 im) re) re))
#s(approx (/ (log im) re) (/.f64 (log.f64 im) re))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (log.f64 im))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 im) #s(literal 3 binary64))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 im)) (*.f64 im im)) #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (fma.f64 (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 im) (*.f64 im im)))) (*.f64 re re) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
#s(approx (pow (* (/ 1/2 im) (* re (/ re im))) 2) (/.f64 (*.f64 (pow.f64 re #s(literal 4 binary64)) #s(literal 1/4 binary64)) (pow.f64 im #s(literal 4 binary64))))
#s(approx (* (/ 1/2 im) (* re (/ re im))) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
#s(approx (* re (/ re im)) (*.f64 (/.f64 re im) re))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 im)) (*.f64 im im)) #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
#s(approx (* (* (/ 1/2 im) (* re (/ re im))) (log im)) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 im)) (*.f64 im im)) #s(literal 1/2 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 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (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 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 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 #s(literal -1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (log.f64 re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #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)))) (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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* 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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* re (* (/ re im) 1/2)) im) (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))
#s(approx (+ (* re (* (/ re im) 1/2)) im) (*.f64 (+.f64 (/.f64 im (*.f64 re re)) (/.f64 #s(literal 1/2 binary64) 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 (*.f64 im im) (*.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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (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)))) (/.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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))))) (/.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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re)))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (*.f64 (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (-.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (neg.f64 (/.f64 (*.f64 (pow.f64 (*.f64 (log.f64 im) im) #s(literal 2 binary64)) #s(literal 0 binary64)) (pow.f64 re #s(literal 4 binary64))))) (/.f64 (neg.f64 (log.f64 im)) (*.f64 re re))) (*.f64 re re)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (-.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (log.f64 im)) (*.f64 (pow.f64 (*.f64 (log.f64 im) im) #s(literal 2 binary64)) #s(literal 0 binary64))) (pow.f64 re #s(literal 6 binary64))) #s(literal -2 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 im) im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 im) im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 2 binary64) (/.f64 (neg.f64 (log.f64 im)) (*.f64 re re))))) (*.f64 re re)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (*.f64 (fma.f64 (pow.f64 im #s(literal -6 binary64)) #s(literal 1/8 binary64) (/.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (/.f64 (*.f64 (pow.f64 re #s(literal 4 binary64)) #s(literal 1/4 binary64)) (pow.f64 im #s(literal 4 binary64))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (*.f64 (fma.f64 (/.f64 (log.f64 im) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal -1/2 binary64) (*.f64 (pow.f64 im #s(literal -4 binary64)) #s(literal 1/4 binary64))) (pow.f64 re #s(literal 4 binary64))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (*.f64 (-.f64 (fma.f64 (pow.f64 im #s(literal -4 binary64)) #s(literal 1/4 binary64) (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (*.f64 (/.f64 (*.f64 (*.f64 re re) (log.f64 im)) (*.f64 im im)) #s(literal -1/2 binary64)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (*.f64 (-.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (*.f64 im im))) (*.f64 re re)))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) 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 (log.f64 (/.f64 #s(literal -1 binary64) 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 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) 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 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -1/2 binary64) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal 1 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #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)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #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)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (sqrt (+ (* 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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #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 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (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 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal 1/720 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #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)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re))))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (*.f64 (neg.f64 re) (fma.f64 (/.f64 (/.f64 (log.f64 im) re) re) #s(literal -1 binary64) (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal -2 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 (fma.f64 (/.f64 (*.f64 im im) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (*.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal -2 binary64)) (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 (fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal -4 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64))))) (*.f64 im im) (*.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal -2 binary64)) (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 (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal -2 binary64)))) (*.f64 im im)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 (fma.f64 (fma.f64 (pow.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64) (/.f64 (*.f64 #s(literal -1/6 binary64) (*.f64 im im)) (pow.f64 re #s(literal 6 binary64)))) (*.f64 im im) (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal -2 binary64)))) (*.f64 im im)) (log.f64 re)))
#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 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (*.f64 im im) (*.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.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) (pow.f64 re #s(literal 3 binary64))) #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 (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal -3 binary64)))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re))
#s(approx (+ (* re (* (/ re im) 1/2)) im) (/.f64 (fma.f64 (*.f64 re re) #s(literal 1/2 binary64) (*.f64 im im)) im))
#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 (*.f64 im im) (*.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 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (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 (fma.f64 (/.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (*.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))))) (*.f64 im im) (*.f64 (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 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 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (*.f64 im im) (*.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 im im) (log.f64 re)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (*.f64 im im) (log.f64 im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))
#s(approx (* im im) (*.f64 im im))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (/.f64 (fma.f64 (*.f64 im im) (log.f64 im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (/.f64 (fma.f64 (*.f64 im im) (/.f64 (log.f64 im) re) (*.f64 #s(literal 1/2 binary64) re)) (*.f64 im im)))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 (fma.f64 (*.f64 im im) (/.f64 (/.f64 (log.f64 im) re) re) #s(literal 1/2 binary64)) (*.f64 im im)))
#s(approx (pow im -2) (pow.f64 im #s(literal -2 binary64)))
#s(approx (log im) (log.f64 im))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (*.f64 im im) (log.f64 im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (fma.f64 (*.f64 #s(literal -1 binary64) (*.f64 im im)) (*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 re re)) #s(literal 0 binary64)) (log.f64 im)) (*.f64 im im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (fma.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (log.f64 im)) (*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 re re)) #s(literal 0 binary64))) (*.f64 re re)) #s(literal -2 binary64)) (*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 re re)) #s(literal 0 binary64))) (*.f64 im im) (log.f64 im)) (*.f64 im im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (/.f64 (fma.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))))
#s(approx (pow (log im) 3) (pow.f64 (log.f64 im) #s(literal 3 binary64)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (/.f64 (fma.f64 (*.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (log.f64 im)) #s(literal -1/2 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) #s(literal 1/4 binary64))) (pow.f64 im #s(literal 4 binary64))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 im) im) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (log.f64 im))) (*.f64 im im) (*.f64 (pow.f64 re #s(literal 4 binary64)) #s(literal 1/4 binary64))) (pow.f64 im #s(literal 4 binary64))))
#s(approx (/ 1/2 im) (/.f64 #s(literal 1/2 binary64) im))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 im) im) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (log.f64 im))) (*.f64 im im)))
#s(approx (pow (log im) 2) (pow.f64 (log.f64 im) #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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 4 binary64)) #s(literal 1/4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (log.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) #s(literal 1 binary64)) im))
#s(approx (+ (* re (* (/ re im) 1/2)) im) (*.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) #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 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (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 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (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 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (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.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (log.f64 im)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (log.f64 im))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (log.f64 im))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (/.f64 (log.f64 im) re))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (fma.f64 (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) re)))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 (/.f64 (log.f64 im) re) re))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)))
#s(approx (/ (/ (log im) re) re) (/.f64 (/.f64 (log.f64 im) re) re))
#s(approx (/ (log im) re) (/.f64 (log.f64 im) re))
#s(approx (log im) (log.f64 im))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (log.f64 im))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (-.f64 (fma.f64 (/.f64 (*.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))) #s(literal 0 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1 binary64) (log.f64 im)) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal -1/2 binary64))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (-.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))) #s(literal 0 binary64)) (neg.f64 (log.f64 im)))) #s(literal 1/2 binary64) (log.f64 im)) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 im))) #s(literal 0 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal -1/2 binary64)))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 im) #s(literal 3 binary64))))
#s(approx (pow (log im) 3) (pow.f64 (log.f64 im) #s(literal 3 binary64)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (fma.f64 (/.f64 (*.f64 (neg.f64 (log.f64 im)) (*.f64 re re)) (*.f64 im im)) #s(literal 1/2 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 (/.f64 (*.f64 (neg.f64 (log.f64 im)) (*.f64 re re)) (*.f64 im im)) #s(literal -1/2 binary64))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (fma.f64 (/.f64 (*.f64 (neg.f64 (log.f64 im)) (*.f64 re re)) (*.f64 im im)) #s(literal 1/2 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))
#s(approx (pow (log im) 2) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))
#s(approx (* (* (/ 1/2 im) (* re (/ re im))) (log im)) (*.f64 (/.f64 (*.f64 (neg.f64 (log.f64 im)) (*.f64 re re)) (*.f64 im im)) #s(literal -1/2 binary64)))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal -1/2 binary64) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal 1 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 4 binary64)) #s(literal 1/4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal -1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) #s(literal 1 binary64))))
#s(approx (+ (* re (* (/ re im) 1/2)) im) (*.f64 (neg.f64 im) (-.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) #s(literal 1/720 binary64) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (+.f64 (log.f64 #s(literal -1 binary64)) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (*.f64 (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)) (*.f64 re re)))
#s(approx (* (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) re) (fma.f64 (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)) (*.f64 re re) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (*.f64 (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)) re))
#s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (fma.f64 (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)) re (*.f64 (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64))))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)))
#s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (fma.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 re re)) #s(literal -1 binary64) (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal -1 binary64)) (*.f64 re re)))))
#s(approx (/ (/ (log im) re) re) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)))
#s(approx (/ (log im) re) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) re))
#s(approx (log im) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (+.f64 (log.f64 #s(literal -1 binary64)) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (-.f64 (fma.f64 #s(literal -1 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))) #s(literal 0 binary64)) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal -1 binary64))) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal -1/2 binary64))))
#s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (-.f64 (+.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))) #s(literal 0 binary64)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))) (log.f64 #s(literal -1 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 0 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal -1/2 binary64)))))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 3 binary64)))
#s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 3 binary64))))
#s(approx (pow (log im) 3) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 3 binary64)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (fma.f64 (/.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)) (*.f64 im im)) #s(literal -1/2 binary64) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64))))
#s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64))) (*.f64 (/.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)) (*.f64 im im)) #s(literal 1/2 binary64))))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (fma.f64 (/.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)) (*.f64 im im)) #s(literal -1/2 binary64) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64))))
#s(approx (pow (log im) 2) (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)))
#s(approx (* (* (/ 1/2 im) (* re (/ re im))) (log im)) (*.f64 (/.f64 (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (*.f64 re re)) (*.f64 im im)) #s(literal 1/2 binary64)))

eval109.0ms (2.4%)

Memory
-39.4MiB live, 99.1MiB allocated; 26ms collecting garbage
Compiler

Compiled 25 320 to 2 666 computations (89.5% saved)

prune54.0ms (1.2%)

Memory
32.6MiB live, 78.5MiB allocated; 5ms collecting garbage
Pruning

33 alts after pruning (24 fresh and 9 done)

PrunedKeptTotal
New50914523
Fresh91019
Picked235
Done066
Total52033553
Accuracy
99.8%
Counts
553 → 33
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓49.4%
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓49.4%
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓98.6%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)))) (log.f64 #s(literal 1/10 binary64)))
✓98.1%
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
3.7%
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im))))) (log.f64 #s(literal 1/10 binary64)))
✓99.1%
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓98.2%
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
✓98.7%
(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
77.4%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (pow.f64 (log.f64 im) #s(literal 3/2 binary64)) #s(literal 2 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
98.4%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (/.f64 (-.f64 (pow.f64 (log.f64 im) #s(literal 4 binary64)) (pow.f64 (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)) #s(literal 2 binary64))) (fma.f64 (log.f64 im) (log.f64 im) (*.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))))))) (log.f64 #s(literal 10 binary64)))
98.4%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
76.4%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
47.3%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) #s(literal 2 binary64)) #s(approx (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))) (/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 im) im) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (log.f64 im))) (*.f64 im im)))))) (log.f64 #s(literal 10 binary64)))
98.1%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(approx (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im)))) (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (log.f64 #s(literal 10 binary64)))
47.8%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (/.f64 (fma.f64 (*.f64 im im) (log.f64 im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (pow.f64 (pow.f64 re #s(literal -1 binary64)) #s(literal -2 binary64)))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (*.f64 re re))) (pow.f64 (pow.f64 re #s(literal -1 binary64)) #s(literal -2 binary64))))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 re #s(literal -1 binary64)) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64)))
50.7%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (*.f64 re re))) (*.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
3.0%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓3.0%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
3.5%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im)))) (log.f64 #s(literal 10 binary64)))
3.8%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓3.8%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
52.1%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) re) re)) re) re))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
3.7%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
21.4%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 (fma.f64 (*.f64 im im) (/.f64 (/.f64 (log.f64 im) re) re) #s(literal 1/2 binary64)) (*.f64 im im))) re) re))) (log.f64 #s(literal 10 binary64)))
52.1%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 (/.f64 (log.f64 im) re) re)) re) re))) (log.f64 #s(literal 10 binary64)))
3.3%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
50.6%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (/.f64 (*.f64 #s(literal 1 binary64) (log.f64 im)) (*.f64 re re))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
37.5%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (/.f64 (fma.f64 (*.f64 im im) (/.f64 (log.f64 im) re) (*.f64 #s(literal 1/2 binary64) re)) (*.f64 im im))) re))) (log.f64 #s(literal 10 binary64)))
97.4%
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (/.f64 (log.f64 im) re)) re))) (log.f64 #s(literal 10 binary64)))
Compiler

Compiled 3 576 to 1 215 computations (66% saved)

regimes166.0ms (3.7%)

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

8 calls:

33.0ms
im
30.0ms
(*.f64 im im)
27.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
24.0ms
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
13.0ms
re
Results
AccuracySegmentsBranch
99.1%1(*.f64 im im)
99.1%1(*.f64 re re)
99.1%1(+.f64 (*.f64 re re) (*.f64 im im))
99.1%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
99.1%1(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
99.1%1(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
99.1%1re
99.1%1im
Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes85.0ms (1.9%)

Memory
27.9MiB live, 121.3MiB allocated; 3ms collecting garbage
Counts
27 → 1
Calls
Call 1
Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re)) im))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re 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)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (/.f64 (log.f64 im) re)) re))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (/.f64 (*.f64 #s(literal 1 binary64) (log.f64 im)) (*.f64 re re))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (/.f64 (/.f64 (log.f64 im) re) re)) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 (/.f64 (log.f64 im) re) re)) re) re))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (*.f64 im im) (log.f64 im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (/.f64 (fma.f64 (*.f64 im im) (log.f64 im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (/.f64 (fma.f64 (*.f64 im im) (/.f64 (log.f64 im) re) (*.f64 #s(literal 1/2 binary64) re)) (*.f64 im im))) re))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (log im) (* re re))) (/.f64 (fma.f64 (*.f64 im im) (/.f64 (/.f64 (log.f64 im) re) re) #s(literal 1/2 binary64)) (*.f64 im im))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 #s(approx (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) (/.f64 (fma.f64 (*.f64 im im) (/.f64 (/.f64 (log.f64 im) re) re) #s(literal 1/2 binary64)) (*.f64 im im))) re) re))) (log.f64 #s(literal 10 binary64)))
Outputs
(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
Calls

8 calls:

28.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
14.0ms
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
8.0ms
re
7.0ms
im
7.0ms
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
Results
AccuracySegmentsBranch
98.7%1(*.f64 im im)
98.7%1(*.f64 re re)
98.7%1(+.f64 (*.f64 re re) (*.f64 im im))
98.7%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
98.7%1(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
98.7%1(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
98.7%1re
98.7%1im
Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes101.0ms (2.3%)

Memory
-3.9MiB live, 51.6MiB allocated; 100ms collecting garbage
Counts
15 → 1
Calls
Call 1
Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re)) im))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re 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)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 #s(approx (* (+ (* (pow im -2) 1/2) (/ (/ (log im) re) re)) re) (/.f64 (log.f64 im) re)) re))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (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:

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

Compiled 44 to 38 computations (13.6% saved)

regimes34.0ms (0.8%)

Memory
0.7MiB live, 49.9MiB allocated; 13ms collecting garbage
Counts
10 → 1
Calls
Call 1
Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re)) im))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (/ (+ (* (/ (pow re 6) (pow im 6)) 1/8) (pow (log im) 3)) (+ (pow (* (/ 1/2 im) (* re (/ re im))) 2) (- (pow (log im) 2) (* (* (/ 1/2 im) (* re (/ re im))) (log im))))) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im))))) (log.f64 #s(literal 1/10 binary64)))
Outputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
Calls

8 calls:

11.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
(+.f64 (*.f64 re re) (*.f64 im im))
3.0ms
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
Results
AccuracySegmentsBranch
3.8%1(*.f64 im im)
3.8%1(*.f64 re re)
3.8%1(+.f64 (*.f64 re re) (*.f64 im im))
3.8%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
3.8%1(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
3.8%1(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
3.8%1re
3.8%1im
Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes19.0ms (0.4%)

Memory
-14.9MiB live, 29.7MiB allocated; 7ms collecting garbage
Counts
4 → 1
Calls
Call 1
Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
Outputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
Calls

8 calls:

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

Compiled 44 to 38 computations (13.6% saved)

regimes13.0ms (0.3%)

Memory
25.7MiB live, 25.7MiB allocated; 0ms collecting garbage
Accuracy

Total -0.2b remaining (-0.3%)

Threshold costs -0.2b (-0.3%)

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

8 calls:

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

Compiled 44 to 38 computations (13.6% saved)

simplify35.0ms (0.8%)

Memory
3.8MiB live, 48.9MiB allocated; 8ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
046147
167147
2137147
3319147
4789147
51532147
61922147
71922147
Stop Event
1×saturated
Calls
Call 1
Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (*.f64 (*.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))

derivations206.0ms (4.6%)

Memory
-2.1MiB live, 236.1MiB allocated; 36ms collecting garbage
Stop Event
1×fuel
Compiler

Compiled 147 to 45 computations (69.4% saved)

preprocess39.0ms (0.9%)

Memory
-7.7MiB live, 85.0MiB allocated; 7ms collecting garbage
Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 402 to 194 computations (51.7% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...