math.log10 on complex, real part

Time bar (total: 2.3s)

start0.0ms (0%)

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

analyze71.0ms (3.1%)

Memory
20.0MiB live, 97.2MiB allocated; 27ms 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)

sample922.0ms (39.9%)

Memory
-36.7MiB live, 1 215.3MiB allocated; 197ms collecting garbage
Samples
716.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 446.0ms
ival-hypot: 266.0ms (59.6% of total)
ival-log: 117.0ms (26.2% of total)
ival-div!: 61.0ms (13.7% of total)
adjust: 1.0ms (0.2% of total)
Bogosity

explain114.0ms (5%)

Memory
18.8MiB live, 258.8MiB allocated; 15ms collecting garbage
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1270-3(-9.547158873699824e-167 9.882242574084507e-157)(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-rescue1080
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow108
↳(*.f64 re re)overflow59
↳(*.f64 im im)overflow63
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue160
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow16
↳(*.f64 re re)underflow68
↳(*.f64 im im)underflow61
Confusion
Predicted +Predicted -
+1242
-0130
Precision
1.0
Recall
0.9841269841269841
Confusion?
Predicted +Predicted MaybePredicted -
+12402
-00130
Precision?
1.0
Recall?
0.9841269841269841
Freqs
test
numberfreq
0132
1124
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
43.0ms512×0valid
Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 27.0ms
ival-hypot: 10.0ms (37% of total)
ival-mult!: 8.0ms (29.6% of total)
ival-log: 5.0ms (18.5% of total)
ival-div!: 2.0ms (7.4% of total)
ival-add!: 1.0ms (3.7% of total)
adjust: 0.0ms (0% of total)

preprocess8.0ms (0.4%)

Memory
19.3MiB live, 19.3MiB allocated; 0ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02874
16074
211474
314374
418174
Stop Event
1×saturated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶52.3%
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 24 to 20 computations (16.7% saved)

rewrite64.0ms (2.8%)

Memory
-17.1MiB live, 127.1MiB allocated; 15ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01047
01747
14947
037931
Stop Event
1×iter-limit
1×iter-limit
1×iter-limit
1×unsound
1×iter-limit
Counts
10 → 183
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
(/.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)))
(neg.f64 (/.f64 (neg.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 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (hypot.f64 im re))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 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 im) (-.f64 re im))))
(/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 re #s(literal 1 binary64)))
(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)) (pow.f64 re #s(literal 1 binary64)))
(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)) (pow.f64 im #s(literal 1 binary64)))
(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)) (pow.f64 im #s(literal 1 binary64)))
(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)) (pow.f64 re #s(literal 1 binary64)))
(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)) (pow.f64 im #s(literal 1 binary64)))
(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) (pow.f64 re #s(literal 1 binary64)))
(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) (pow.f64 im #s(literal 1 binary64)))
(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) (pow.f64 re #s(literal 1 binary64)))
(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) (pow.f64 im #s(literal 1 binary64)))
(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 (pow.f64 re #s(literal 1 binary64)))
(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 (pow.f64 im #s(literal 1 binary64)))
(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 (-.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 (*.f64 (neg.f64 im) im) #s(literal 3 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (*.f64 re re) (*.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (neg.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (*.f64 (+.f64 re im) (-.f64 re 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 re im) #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))
(neg.f64 (-.f64 (*.f64 (neg.f64 im) im) (*.f64 re re)))
(fma.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) (*.f64 re re))
(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 (neg.f64 (neg.f64 im)) im))
(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 (neg.f64 (neg.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 (neg.f64 (neg.f64 im)) im))
(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 (neg.f64 (neg.f64 im)) im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 re re (*.f64 im im))
(-.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 (neg.f64 re)) (neg.f64 re)))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 re)))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 re) re))
(-.f64 (*.f64 im im) (*.f64 re (neg.f64 re)))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 (neg.f64 im)) (neg.f64 im)))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 im)))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 im) im))
(+.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 (neg.f64 (neg.f64 im)) im))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(*.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 re #s(literal 2 binary64))
(neg.f64 (*.f64 (neg.f64 re) re))
(neg.f64 (*.f64 re (neg.f64 re)))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
re
(*.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(*.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 im #s(literal 2 binary64))
(neg.f64 (*.f64 (neg.f64 im) im))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)

eval22.0ms (0.9%)

Memory
7.1MiB live, 53.9MiB allocated; 2ms collecting garbage
Compiler

Compiled 2 174 to 684 computations (68.5% saved)

prune5.0ms (0.2%)

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

3 alts after pruning (3 fresh and 0 done)

PrunedKeptTotal
New1733176
Fresh000
Picked101
Done000
Total1743177
Accuracy
99.7%
Counts
177 → 3
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶52.3%
(/.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)))
Compiler

Compiled 27 to 25 computations (7.4% saved)

rewrite40.0ms (1.8%)

Memory
-0.3MiB live, 47.2MiB allocated; 2ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01980
03669
19469
060669
Stop Event
1×iter-limit
1×iter-limit
1×node-limit
1×iter-limit
Counts
19 → 331
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 (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)
(/.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)
Outputs
(*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.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 (/.f64 #s(literal 1 binary64) (pow.f64 (hypot.f64 im re) #s(literal -1 binary64))))
(log.f64 (hypot.f64 im re))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 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 re) (-.f64 im re))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 re #s(literal 1 binary64)))
(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)) (pow.f64 re #s(literal 1 binary64)))
(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)) (pow.f64 im #s(literal 1 binary64)))
(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)) (pow.f64 im #s(literal 1 binary64)))
(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)) (pow.f64 re #s(literal 1 binary64)))
(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)) (pow.f64 im #s(literal 1 binary64)))
(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) (pow.f64 re #s(literal 1 binary64)))
(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) (pow.f64 im #s(literal 1 binary64)))
(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) (pow.f64 re #s(literal 1 binary64)))
(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) (pow.f64 im #s(literal 1 binary64)))
(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 (pow.f64 re #s(literal 1 binary64)))
(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 (pow.f64 im #s(literal 1 binary64)))
(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 (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 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.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 (neg.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))))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(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 (/.f64 #s(literal 1 binary64) (pow.f64 (hypot.f64 im re) #s(literal -1 binary64))))
(log.f64 (hypot.f64 im re))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 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 re) (-.f64 im re))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (fabs.f64 re))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (fabs.f64 im))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 re #s(literal 1 binary64)))
(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)) (pow.f64 re #s(literal 1 binary64)))
(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)) (pow.f64 im #s(literal 1 binary64)))
(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)) (pow.f64 im #s(literal 1 binary64)))
(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)) (pow.f64 re #s(literal 1 binary64)))
(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)) (pow.f64 im #s(literal 1 binary64)))
(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) (pow.f64 re #s(literal 1 binary64)))
(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) (pow.f64 im #s(literal 1 binary64)))
(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) (pow.f64 re #s(literal 1 binary64)))
(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) (pow.f64 im #s(literal 1 binary64)))
(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 (pow.f64 re #s(literal 1 binary64)))
(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 (pow.f64 im #s(literal 1 binary64)))
(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 (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)
(*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.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 (/.f64 #s(literal 1 binary64) (pow.f64 (hypot.f64 im re) #s(literal -1 binary64))))
(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 re) (-.f64 im re))))
(-.f64 (log.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(log.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 (-.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 (neg.f64 re) re) #s(literal 3 binary64))) (+.f64 (pow.f64 im #s(literal 4 binary64)) (+.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (*.f64 im im) (*.f64 (neg.f64 re) re)))))
(/.f64 (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 (neg.f64 im) im) #s(literal 3 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (*.f64 re re) (*.f64 (neg.f64 im) im)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (neg.f64 (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (neg.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(/.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))
(neg.f64 (-.f64 (*.f64 (neg.f64 re) re) (*.f64 im im)))
(neg.f64 (-.f64 (*.f64 (neg.f64 im) im) (*.f64 re re)))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) (*.f64 (neg.f64 (neg.f64 re)) re))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 (neg.f64 (neg.f64 re)) re))
(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 (neg.f64 (neg.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 (neg.f64 (neg.f64 im)) im))
(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 (neg.f64 (neg.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 (neg.f64 (neg.f64 re)) re))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 (neg.f64 (neg.f64 re)) re))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 (neg.f64 (neg.f64 re)) re))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 im im (*.f64 (neg.f64 (neg.f64 re)) re))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 (neg.f64 (neg.f64 im)) im))
(fma.f64 re re (*.f64 im im))
(-.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (+.f64 im re) (-.f64 im re))))
(-.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 (neg.f64 re)) (neg.f64 re)))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 re)))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 re) re))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 (neg.f64 im)) (neg.f64 im)))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 im)))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 im) im))
(+.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+.f64 (*.f64 im im) (*.f64 (neg.f64 (neg.f64 re)) re))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 (neg.f64 (neg.f64 im)) im))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(*.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 re #s(literal 2 binary64))
(neg.f64 (*.f64 (neg.f64 re) re))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))

eval29.0ms (1.3%)

Memory
-29.3MiB live, 68.8MiB allocated; 9ms collecting garbage
Compiler

Compiled 2 535 to 729 computations (71.2% saved)

prune5.0ms (0.2%)

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

5 alts after pruning (2 fresh and 3 done)

PrunedKeptTotal
New1882190
Fresh000
Picked033
Done000
Total1885193
Accuracy
99.7%
Counts
193 → 5
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶52.2%
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
▶17.2%
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))) (log.f64 #s(literal 10 binary64)))
✓52.3%
(/.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)))
Compiler

Compiled 67 to 57 computations (14.9% saved)

rewrite67.0ms (2.9%)

Memory
9.5MiB live, 104.1MiB allocated; 6ms collecting garbage
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
030197
052224
1183149
01310149
Stop Event
1×iter-limit
1×iter-limit
1×node-limit
1×iter-limit
Counts
30 → 367
Calls
Call 1
Inputs
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))))
#s(literal 1/2 binary64)
(-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))
(+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))
(pow.f64 im #s(literal 6 binary64))
im
#s(literal 6 binary64)
(pow.f64 re #s(literal 6 binary64))
re
(log.f64 (+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))
(-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64)))
(pow.f64 re #s(literal 4 binary64))
#s(literal 4 binary64)
(pow.f64 (*.f64 im re) #s(literal 2 binary64))
(*.f64 im re)
#s(literal 2 binary64)
(pow.f64 im #s(literal 4 binary64))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (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)
#s(literal -1/2 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
Outputs
(*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal -1/2 binary64))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1/2 binary64))
(*.f64 #s(literal -1/2 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(*.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))))
(/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (pow.f64 (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))))) #s(literal 3 binary64))) #s(literal 1/2 binary64)) (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64)))) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (pow.f64 (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))))) #s(literal 3 binary64)))) (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64))))
(neg.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal -1/2 binary64))))
(fma.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 1/2 binary64) (*.f64 (neg.f64 (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)))))) #s(literal 1/2 binary64)))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (*.f64 #s(literal 1/2 binary64) (neg.f64 (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))))))))
(+.f64 (*.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 1/2 binary64)) (*.f64 (neg.f64 (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)))))) #s(literal 1/2 binary64)))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))) (*.f64 #s(literal 1/2 binary64) (neg.f64 (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 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64)))
#s(literal 1/2 binary64)
(/.f64 (+.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (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)))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (*.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (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))))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64)))) (neg.f64 (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (pow.f64 (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))))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) (-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (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))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (pow.f64 (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))))) #s(literal 3 binary64))) (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)))) (/.f64 (pow.f64 (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))))) #s(literal 3 binary64)) (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 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 re) (-.f64 im re))))
(-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #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))))))
(+.f64 (neg.f64 (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 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
(+.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (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 im im (*.f64 re re)))
(-.f64 (log.f64 (-.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64)))) (log.f64 (-.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))
(-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64)))) (log.f64 (-.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (pow.f64 (*.f64 re im) #s(literal 6 binary64)))))
(log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))
(*.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)))) (fma.f64 im im (*.f64 re re)))
(/.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64)))) (neg.f64 (-.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64)))) (neg.f64 (-.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (pow.f64 (*.f64 re im) #s(literal 6 binary64)))))
(/.f64 (-.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (-.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))
(/.f64 (+.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (+.f64 (pow.f64 re #s(literal 12 binary64)) (-.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 (*.f64 re im) #s(literal 6 binary64)))))
(/.f64 (+.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (-.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (pow.f64 (*.f64 re im) #s(literal 6 binary64))))
(fma.f64 (pow.f64 (*.f64 im im) #s(literal 3/2 binary64)) (pow.f64 (*.f64 im im) #s(literal 3/2 binary64)) (pow.f64 re #s(literal 6 binary64)))
(fma.f64 (pow.f64 (*.f64 re re) #s(literal 3/2 binary64)) (pow.f64 (*.f64 re re) #s(literal 3/2 binary64)) (pow.f64 im #s(literal 6 binary64)))
(fma.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (neg.f64 (pow.f64 im #s(literal 3 binary64))) (pow.f64 re #s(literal 6 binary64)))
(fma.f64 (neg.f64 (pow.f64 re #s(literal 3 binary64))) (neg.f64 (pow.f64 re #s(literal 3 binary64))) (pow.f64 im #s(literal 6 binary64)))
(fma.f64 (fabs.f64 (pow.f64 im #s(literal 3 binary64))) (fabs.f64 (pow.f64 im #s(literal 3 binary64))) (pow.f64 re #s(literal 6 binary64)))
(fma.f64 (fabs.f64 (pow.f64 re #s(literal 3 binary64))) (fabs.f64 (pow.f64 re #s(literal 3 binary64))) (pow.f64 im #s(literal 6 binary64)))
(fma.f64 (pow.f64 (neg.f64 im) #s(literal 3 binary64)) (pow.f64 (neg.f64 im) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))
(fma.f64 (pow.f64 (fabs.f64 im) #s(literal 3 binary64)) (pow.f64 (fabs.f64 im) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))
(fma.f64 (pow.f64 (neg.f64 re) #s(literal 3 binary64)) (pow.f64 (neg.f64 re) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)))
(fma.f64 (pow.f64 (fabs.f64 re) #s(literal 3 binary64)) (pow.f64 (fabs.f64 re) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)))
(fma.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)))
(fma.f64 (*.f64 im im) (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 6 binary64)))
(fma.f64 (*.f64 re re) (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 6 binary64)))
(fma.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 im im) (pow.f64 re #s(literal 6 binary64)))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 re re) (pow.f64 im #s(literal 6 binary64)))
(-.f64 (/.f64 (pow.f64 im #s(literal 12 binary64)) (-.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (pow.f64 re #s(literal 12 binary64)) (-.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))
(-.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (pow.f64 im #s(literal 3 binary64))))
(-.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (neg.f64 (pow.f64 re #s(literal 3 binary64))) (pow.f64 re #s(literal 3 binary64))))
(+.f64 (/.f64 (pow.f64 im #s(literal 18 binary64)) (-.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (pow.f64 (*.f64 re im) #s(literal 6 binary64)))) (/.f64 (pow.f64 re #s(literal 18 binary64)) (-.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (pow.f64 (*.f64 re im) #s(literal 6 binary64)))))
(+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))
(+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))
(*.f64 (pow.f64 (*.f64 im im) #s(literal 3/2 binary64)) (pow.f64 (*.f64 im im) #s(literal 3/2 binary64)))
(*.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (neg.f64 (pow.f64 im #s(literal 3 binary64))))
(*.f64 (fabs.f64 (pow.f64 im #s(literal 3 binary64))) (fabs.f64 (pow.f64 im #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 (*.f64 im im) (pow.f64 im #s(literal 4 binary64)))
(*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 im im))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 6 binary64))
(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 (log.f64 (*.f64 im 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))))
im
#s(literal 6 binary64)
(*.f64 (pow.f64 (*.f64 re re) #s(literal 3/2 binary64)) (pow.f64 (*.f64 re re) #s(literal 3/2 binary64)))
(*.f64 (neg.f64 (pow.f64 re #s(literal 3 binary64))) (neg.f64 (pow.f64 re #s(literal 3 binary64))))
(*.f64 (fabs.f64 (pow.f64 re #s(literal 3 binary64))) (fabs.f64 (pow.f64 re #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 (*.f64 re re) (pow.f64 re #s(literal 4 binary64)))
(*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 re re))
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 6 binary64))
(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 (log.f64 (*.f64 re 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))))
re
(-.f64 (log.f64 (-.f64 (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64)) (pow.f64 im #s(literal 8 binary64)))) (log.f64 (-.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 3 binary64)))) (log.f64 (fma.f64 (pow.f64 im #s(literal 4 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)))) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 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)))))
(/.f64 (-.f64 (pow.f64 re #s(literal 8 binary64)) (*.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(/.f64 (-.f64 (pow.f64 im #s(literal 8 binary64)) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 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)))))
(/.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 re #s(literal 8 binary64)) (fma.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64)) (pow.f64 im #s(literal 8 binary64)))) (neg.f64 (-.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (pow.f64 im #s(literal 4 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)))) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64)) (pow.f64 im #s(literal 8 binary64))) (-.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(/.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 im #s(literal 8 binary64)) (-.f64 (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 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)))))))
(/.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (pow.f64 im #s(literal 4 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)))) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64))))
(neg.f64 (-.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))
(fma.f64 (*.f64 (*.f64 re re) (neg.f64 re)) (neg.f64 re) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (*.f64 (*.f64 re re) (neg.f64 re)) (neg.f64 re) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (*.f64 (*.f64 re re) (fabs.f64 re)) (fabs.f64 re) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (*.f64 (*.f64 re re) (fabs.f64 re)) (fabs.f64 re) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (*.f64 (*.f64 im im) (neg.f64 im)) (neg.f64 im) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 (*.f64 im im) (fabs.f64 im)) (fabs.f64 im) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (fma.f64 re re (*.f64 re im)) (-.f64 (*.f64 re re) (*.f64 re im)) (pow.f64 im #s(literal 4 binary64)))
(fma.f64 (*.f64 (neg.f64 re) (fabs.f64 re)) (*.f64 (neg.f64 re) (fabs.f64 re)) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (*.f64 (neg.f64 re) (fabs.f64 re)) (*.f64 (neg.f64 re) (fabs.f64 re)) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (*.f64 (fabs.f64 re) (neg.f64 re)) (*.f64 (fabs.f64 re) (neg.f64 re)) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (*.f64 (fabs.f64 re) (neg.f64 re)) (*.f64 (fabs.f64 re) (neg.f64 re)) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (*.f64 (fabs.f64 re) re) (*.f64 (fabs.f64 re) re) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (*.f64 (fabs.f64 re) re) (*.f64 (fabs.f64 re) re) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (*.f64 re (fabs.f64 re)) (*.f64 re (fabs.f64 re)) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (*.f64 re (fabs.f64 re)) (*.f64 re (fabs.f64 re)) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (*.f64 (neg.f64 im) (fabs.f64 im)) (*.f64 (neg.f64 im) (fabs.f64 im)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 (neg.f64 im) im) (*.f64 (neg.f64 im) im) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 (fabs.f64 im) (neg.f64 im)) (*.f64 (fabs.f64 im) (neg.f64 im)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 (fabs.f64 im) im) (*.f64 (fabs.f64 im) im) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 im (neg.f64 im)) (*.f64 im (neg.f64 im)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 im (fabs.f64 im)) (*.f64 im (fabs.f64 im)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (neg.f64 (*.f64 im im)) (neg.f64 (*.f64 im im)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 (neg.f64 re) re) (*.f64 (neg.f64 re) re) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (*.f64 (neg.f64 re) re) (*.f64 (neg.f64 re) re) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (pow.f64 im #s(literal 3 binary64)) im (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) re (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) re (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (neg.f64 re) (*.f64 (neg.f64 re) (*.f64 re re)) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (neg.f64 re) (*.f64 (neg.f64 re) (*.f64 re re)) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (neg.f64 im) (*.f64 (neg.f64 im) (*.f64 im im)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (fabs.f64 re) (*.f64 (fabs.f64 re) (*.f64 re re)) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (fabs.f64 re) (*.f64 (fabs.f64 re) (*.f64 re re)) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (fabs.f64 im) (*.f64 (fabs.f64 im) (*.f64 im im)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 im im) (*.f64 im im) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))
(fma.f64 (*.f64 re re) (*.f64 re re) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 (*.f64 re re) (*.f64 re re) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 re (pow.f64 re #s(literal 3 binary64)) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(fma.f64 re (pow.f64 re #s(literal 3 binary64)) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 im (pow.f64 im #s(literal 3 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(-.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))
(-.f64 (/.f64 (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64)) (-.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (pow.f64 im #s(literal 8 binary64)) (-.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(-.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (*.f64 (neg.f64 (*.f64 im im)) (*.f64 im im)))
(-.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))
(+.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(+.f64 (/.f64 (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 3 binary64)) (fma.f64 (pow.f64 im #s(literal 4 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)))) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64)))) (/.f64 (pow.f64 im #s(literal 12 binary64)) (fma.f64 (pow.f64 im #s(literal 4 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)))) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 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))))
(+.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))
(+.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(+.f64 (pow.f64 re #s(literal 4 binary64)) (+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(*.f64 (fma.f64 re re (*.f64 re im)) (-.f64 (*.f64 re re) (*.f64 re im)))
(*.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)))
(/.f64 (+.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 re #s(literal 8 binary64)) (-.f64 (pow.f64 (*.f64 re im) #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 8 binary64)) (pow.f64 (*.f64 re im) #s(literal 4 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 (*.f64 re im) #s(literal 6 binary64)))) (neg.f64 (+.f64 (fma.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 4 binary64))) (pow.f64 re #s(literal 8 binary64)))))
(/.f64 (-.f64 (pow.f64 re #s(literal 8 binary64)) (pow.f64 (*.f64 re im) #s(literal 4 binary64))) (+.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))
(/.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 (*.f64 re im) #s(literal 6 binary64))) (+.f64 (fma.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 4 binary64))) (pow.f64 re #s(literal 8 binary64))))
(neg.f64 (-.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))
(fma.f64 (*.f64 (*.f64 re re) (neg.f64 re)) (neg.f64 re) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 (*.f64 re re) (fabs.f64 re)) (fabs.f64 re) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 (neg.f64 re) (fabs.f64 re)) (*.f64 (neg.f64 re) (fabs.f64 re)) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 (fabs.f64 re) (neg.f64 re)) (*.f64 (fabs.f64 re) (neg.f64 re)) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 (fabs.f64 re) re) (*.f64 (fabs.f64 re) re) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 re (fabs.f64 re)) (*.f64 re (fabs.f64 re)) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (neg.f64 (*.f64 re im)) (*.f64 re im) (pow.f64 re #s(literal 4 binary64)))
(fma.f64 (neg.f64 (*.f64 im im)) (*.f64 re re) (pow.f64 re #s(literal 4 binary64)))
(fma.f64 (*.f64 (neg.f64 re) re) (*.f64 (neg.f64 re) re) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) re (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (neg.f64 re) (*.f64 (neg.f64 re) (*.f64 re re)) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (fabs.f64 re) (*.f64 (fabs.f64 re) (*.f64 re re)) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 im im) (*.f64 (neg.f64 re) re) (pow.f64 re #s(literal 4 binary64)))
(fma.f64 (*.f64 re re) (*.f64 re re) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(fma.f64 (*.f64 re im) (neg.f64 (*.f64 re im)) (pow.f64 re #s(literal 4 binary64)))
(fma.f64 re (pow.f64 re #s(literal 3 binary64)) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(-.f64 (/.f64 (pow.f64 re #s(literal 8 binary64)) (+.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (pow.f64 (*.f64 re im) #s(literal 4 binary64)) (+.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))))
(-.f64 (/.f64 (pow.f64 re #s(literal 12 binary64)) (+.f64 (fma.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 4 binary64))) (pow.f64 re #s(literal 8 binary64)))) (/.f64 (pow.f64 (*.f64 re im) #s(literal 6 binary64)) (+.f64 (fma.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 4 binary64))) (pow.f64 re #s(literal 8 binary64)))))
(-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))
(+.f64 (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))
(+.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64))))
(*.f64 (*.f64 (*.f64 re re) (neg.f64 re)) (neg.f64 re))
(*.f64 (*.f64 (*.f64 re re) (fabs.f64 re)) (fabs.f64 re))
(*.f64 (*.f64 (neg.f64 re) (fabs.f64 re)) (*.f64 (neg.f64 re) (fabs.f64 re)))
(*.f64 (*.f64 (fabs.f64 re) (neg.f64 re)) (*.f64 (fabs.f64 re) (neg.f64 re)))
(*.f64 (*.f64 (fabs.f64 re) re) (*.f64 (fabs.f64 re) re))
(*.f64 (*.f64 re (fabs.f64 re)) (*.f64 re (fabs.f64 re)))
(*.f64 (*.f64 (neg.f64 re) re) (*.f64 (neg.f64 re) re))
(*.f64 (pow.f64 re #s(literal 3 binary64)) re)
(*.f64 (neg.f64 re) (*.f64 (neg.f64 re) (*.f64 re re)))
(*.f64 (fabs.f64 re) (*.f64 (fabs.f64 re) (*.f64 re re)))
(*.f64 (*.f64 re re) (*.f64 re re))
(*.f64 re (pow.f64 re #s(literal 3 binary64)))
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 4 binary64))
(pow.f64 (*.f64 re re) #s(literal 2 binary64))
(pow.f64 re #s(literal 4 binary64))
(exp.f64 (*.f64 (log.f64 re) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 re) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 re) #s(literal 4 binary64))))
#s(literal 4 binary64)
(*.f64 (*.f64 (*.f64 im im) (neg.f64 re)) (neg.f64 re))
(*.f64 (*.f64 (*.f64 im im) (fabs.f64 re)) (fabs.f64 re))
(*.f64 (*.f64 (*.f64 im im) re) re)
(*.f64 (*.f64 (*.f64 re im) re) im)
(*.f64 (*.f64 (*.f64 re im) im) re)
(*.f64 (*.f64 (neg.f64 im) (neg.f64 re)) (*.f64 (neg.f64 im) (neg.f64 re)))
(*.f64 (*.f64 (neg.f64 im) (fabs.f64 re)) (*.f64 (neg.f64 im) (fabs.f64 re)))
(*.f64 (*.f64 (neg.f64 im) re) (*.f64 (neg.f64 im) re))
(*.f64 (*.f64 (fabs.f64 im) (neg.f64 re)) (*.f64 (fabs.f64 im) (neg.f64 re)))
(*.f64 (*.f64 (fabs.f64 im) (fabs.f64 re)) (*.f64 (fabs.f64 im) (fabs.f64 re)))
(*.f64 (*.f64 (fabs.f64 im) re) (*.f64 (fabs.f64 im) re))
(*.f64 (*.f64 im (neg.f64 re)) (*.f64 im (neg.f64 re)))
(*.f64 (*.f64 im (fabs.f64 re)) (*.f64 im (fabs.f64 re)))
(*.f64 (neg.f64 (*.f64 re im)) (neg.f64 (*.f64 re im)))
(*.f64 (fabs.f64 (*.f64 re im)) (fabs.f64 (*.f64 re im)))
(*.f64 (exp.f64 (log.f64 (*.f64 re im))) (exp.f64 (log.f64 (*.f64 re im))))
(*.f64 (neg.f64 im) (*.f64 (neg.f64 im) (*.f64 re re)))
(*.f64 (fabs.f64 im) (*.f64 (fabs.f64 im) (*.f64 re re)))
(*.f64 (*.f64 im im) (*.f64 re re))
(*.f64 (*.f64 re re) (*.f64 im im))
(*.f64 (*.f64 re im) (*.f64 re im))
(*.f64 re (*.f64 im (*.f64 re im)))
(*.f64 im (*.f64 im (*.f64 re re)))
(*.f64 im (*.f64 re (*.f64 re im)))
(pow.f64 (exp.f64 (log.f64 (*.f64 re im))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (*.f64 re im) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (*.f64 re im) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (*.f64 re im)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 (*.f64 re im)) #s(literal 2 binary64))) (sinh.f64 (*.f64 (log.f64 (*.f64 re im)) #s(literal 2 binary64))))
(*.f64 (pow.f64 (*.f64 re im) #s(literal 1/2 binary64)) (pow.f64 (*.f64 re im) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(*.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(*.f64 re im)
(*.f64 im re)
(pow.f64 (*.f64 re im) #s(literal 1 binary64))
(exp.f64 (*.f64 (log.f64 (*.f64 re im)) #s(literal 1 binary64)))
#s(literal 2 binary64)
(*.f64 (*.f64 (*.f64 im im) (neg.f64 im)) (neg.f64 im))
(*.f64 (*.f64 (*.f64 im im) (fabs.f64 im)) (fabs.f64 im))
(*.f64 (*.f64 (neg.f64 im) (fabs.f64 im)) (*.f64 (neg.f64 im) (fabs.f64 im)))
(*.f64 (*.f64 (neg.f64 im) im) (*.f64 (neg.f64 im) im))
(*.f64 (*.f64 (fabs.f64 im) (neg.f64 im)) (*.f64 (fabs.f64 im) (neg.f64 im)))
(*.f64 (*.f64 (fabs.f64 im) im) (*.f64 (fabs.f64 im) im))
(*.f64 (*.f64 im (neg.f64 im)) (*.f64 im (neg.f64 im)))
(*.f64 (*.f64 im (fabs.f64 im)) (*.f64 im (fabs.f64 im)))
(*.f64 (neg.f64 (*.f64 im im)) (neg.f64 (*.f64 im im)))
(*.f64 (pow.f64 im #s(literal 3 binary64)) im)
(*.f64 (neg.f64 im) (*.f64 (neg.f64 im) (*.f64 im im)))
(*.f64 (fabs.f64 im) (*.f64 (fabs.f64 im) (*.f64 im im)))
(*.f64 (*.f64 im im) (*.f64 im im))
(*.f64 im (pow.f64 im #s(literal 3 binary64)))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 4 binary64))
(pow.f64 (*.f64 im im) #s(literal 2 binary64))
(pow.f64 im #s(literal 4 binary64))
(exp.f64 (*.f64 (log.f64 im) #s(literal 4 binary64)))
(+.f64 (cosh.f64 (*.f64 (log.f64 im) #s(literal 4 binary64))) (sinh.f64 (*.f64 (log.f64 im) #s(literal 4 binary64))))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal -1/2 binary64))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (neg.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))))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(neg.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))))
(log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal -1/2 binary64)))
(/.f64 (+.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (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)))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (*.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (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))))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64)))) (neg.f64 (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (pow.f64 (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))))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) (-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (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))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (pow.f64 (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))))) #s(literal 3 binary64))) (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 3 binary64)) (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)))) (/.f64 (pow.f64 (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))))) #s(literal 3 binary64)) (fma.f64 (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 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 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 re) (-.f64 im re))))
(-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #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))))))
(+.f64 (neg.f64 (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 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
(+.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (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 im im (*.f64 re re)))
(*.f64 (/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (-.f64 (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64)) (pow.f64 im #s(literal 8 binary64)))) (-.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64))))
(*.f64 (/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 3 binary64)))) (fma.f64 (pow.f64 im #s(literal 4 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)))) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #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 6 binary64)) (pow.f64 (*.f64 (neg.f64 re) re) #s(literal 3 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)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #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 re im) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (-.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 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))))))
(/.f64 (+.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (*.f64 (-.f64 (+.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (pow.f64 (*.f64 re im) #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))))))
(/.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 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))
(neg.f64 (-.f64 (*.f64 (neg.f64 re) re) (*.f64 im im)))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 (neg.f64 (neg.f64 re)) re))
(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 (neg.f64 (neg.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 (neg.f64 (neg.f64 re)) re))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) (*.f64 (neg.f64 (neg.f64 re)) re))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) im (*.f64 (neg.f64 (neg.f64 re)) re))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) im (*.f64 re re))
(fma.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 re #s(literal 1 binary64)) re (*.f64 im im))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 (neg.f64 (neg.f64 re)) re))
(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 (neg.f64 (neg.f64 re)) re))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 (neg.f64 (neg.f64 re)) re))
(fma.f64 im im (*.f64 re re))
(-.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (+.f64 im re) (-.f64 im re))))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 (neg.f64 re)) (neg.f64 re)))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 re)))
(-.f64 (*.f64 im im) (*.f64 (neg.f64 re) re))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 (neg.f64 im)) (neg.f64 im)))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 im)))
(-.f64 (*.f64 re re) (*.f64 (neg.f64 im) im))
(-.f64 (*.f64 re re) (*.f64 im (neg.f64 im)))
(+.f64 (/.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 re im) #s(literal 2 binary64))))) (/.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 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 re im) #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 re im) #s(literal 2 binary64))))))
(+.f64 (*.f64 im im) (*.f64 (neg.f64 (neg.f64 re)) re))
(+.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 (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 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 re #s(literal 2 binary64))
(neg.f64 (*.f64 (neg.f64 re) re))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
#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)

eval40.0ms (1.7%)

Memory
-2.8MiB live, 93.6MiB allocated; 8ms collecting garbage
Compiler

Compiled 10 163 to 1 876 computations (81.5% saved)

prune9.0ms (0.4%)

Memory
-23.5MiB live, 23.9MiB allocated; 1ms collecting garbage
Pruning

7 alts after pruning (3 fresh and 4 done)

PrunedKeptTotal
New3193322
Fresh000
Picked112
Done033
Total3207327
Accuracy
99.7%
Counts
327 → 7
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶10.6%
(/.f64 (/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64)))
✓52.2%
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
▶10.6%
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))) (log.f64 #s(literal 10 binary64)))
▶17.2%
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))))) (log.f64 #s(literal 10 binary64)))
✓52.3%
(/.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)))
Compiler

Compiled 201 to 110 computations (45.3% saved)

series306.0ms (13.2%)

Memory
38.5MiB live, 654.3MiB allocated; 53ms collecting garbage
Counts
42 → 522
Calls
Call 1
Inputs
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64))))))
#s(literal 1/2 binary64)
(-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))))
(log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))
(+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))
(pow.f64 im #s(literal 6 binary64))
im
#s(literal 6 binary64)
(pow.f64 re #s(literal 6 binary64))
re
(log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))
(*.f64 re re)
(-.f64 (*.f64 re re) (*.f64 im im))
(*.f64 im im)
(pow.f64 im #s(literal 4 binary64))
#s(literal 4 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))))
(-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64))
(log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))
(+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))
#s(literal 2 binary64)
(log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))
(*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 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))))
(-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))
(pow.f64 re #s(literal 4 binary64))
(pow.f64 (*.f64 re im) #s(literal 2 binary64))
(*.f64 re im)
(/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(pow.f64 (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))))) #s(literal 2 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)))))
(/.f64 (/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64))
(-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64)))
Outputs
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (log (pow im 6)) (log (pow im 4))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow im 6)) (log (pow im 4))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow im 6)) (log (pow im 4))) (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow im 6)) (log (pow im 4))) (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (log (pow im 6)) (log (pow im 4))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow im 6)) (log (pow im 4)))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow im 6)) (log (pow im 4)))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow im 6)) (log (pow im 4)))) (* (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (log (pow im 6)) (log (pow im 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow im 6)) (/ (pow re 2) (pow im 2))) (log (pow im 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow im 6)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (log (pow im 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow im 6)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (log (pow im 4)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (log (pow im 6))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow im 6)) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow im 6)) (* (pow re 6) (+ (* -1/2 (/ (pow re 6) (pow im 12))) (/ 1 (pow im 6)))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow im 6)) (* (pow re 6) (+ (* (pow re 6) (- (* 1/3 (/ (pow re 6) (pow im 18))) (* 1/2 (/ 1 (pow im 12))))) (/ 1 (pow im 6)))))))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (pow im 6)))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (+ (pow im 6) (pow re 6))))
#s(approx (pow re 6) #s(hole binary64 (pow re 6)))
#s(approx re #s(hole binary64 re))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (log (pow im 4))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow im 4)) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow im 4)) (* (pow re 2) (- (* 1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow im 4)) (* (pow re 2) (- (* (pow re 2) (+ (* 2/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (pow im 4)))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow im 4))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1 (pow im 2)) (pow re 2))) (pow im 4))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (- (pow re 2) (pow im 2))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (* (pow re 2) (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))))))) (* 1/2 (/ (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))) (log 10))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))) (log 10))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2)))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 3))))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (/ 1 (* (pow im 4) (* (log 10) (log (pow im 10))))) (/ (log (pow im 4)) (* (pow im 4) (* (log 10) (log (pow im 10))))))))))) (* 1/2 (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))) (log 10))) (* (pow re 2) (+ (* 1/2 (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (* (log 10) (log (pow im 10)))))) (+ (* 5/3 (/ (pow (log (pow im 4)) 2) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (* (log 10) (log (pow im 10)))))) (/ 1 (* (pow im 6) (* (log 10) (log (pow im 10))))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 4))))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (* (log 10) (log (pow im 10)))))) (+ (* 5/3 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 2))))) (/ (pow (log (pow im 6)) 2) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 3)))))))))) (* 1/2 (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2)))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 3))))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (/ 1 (* (pow im 4) (* (log 10) (log (pow im 10))))) (/ (log (pow im 4)) (* (pow im 4) (* (log 10) (log (pow im 10)))))))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (* (pow re 2) (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))))) (* 1/2 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10)))))))))) (* 1/2 (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))) (* (pow re 2) (+ (* 1/2 (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 4)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (log (pow im 10))))) (/ 1 (* (pow im 6) (log (pow im 10)))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 4)))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 3))))))))) (* 1/2 (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow re 2) (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10)))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow re 2) (- (+ (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (* (pow re 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10)))))))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10)))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow re 2) (- (+ (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (* (pow re 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (* (pow re 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 4)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (log (pow im 10))))) (/ 1 (* (pow im 6) (log (pow im 10)))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 4)))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 3)))))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10)))))))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10)))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (/ (pow (log (pow im 6)) 2) (log (pow im 10)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (/ (* (pow re 2) (pow (log (pow im 6)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))) (/ (pow (log (pow im 6)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* (pow re 2) (- (* 2 (/ (log (pow im 6)) (* (pow im 6) (log (pow im 10))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 4)))) (+ (* 5/3 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 3))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (pow (log (pow im 6)) 2)))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* 2 (/ (* (pow re 6) (log (pow im 6))) (pow im 6))) (pow (log (pow im 6)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* (pow re 6) (+ (* 2 (/ (log (pow im 6)) (pow im 6))) (* (pow re 6) (+ (* -1 (/ (log (pow im 6)) (pow im 12))) (/ 1 (pow im 12)))))) (pow (log (pow im 6)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* (pow re 6) (+ (* 2 (/ (log (pow im 6)) (pow im 6))) (* (pow re 6) (+ (* -1 (/ (log (pow im 6)) (pow im 12))) (+ (* (pow re 6) (- (* 2/3 (/ (log (pow im 6)) (pow im 18))) (/ 1 (pow im 18)))) (/ 1 (pow im 12))))))) (pow (log (pow im 6)) 2))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (log (pow im 6))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow im 6)) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow im 6)) (* (pow re 6) (+ (* -1/2 (/ (pow re 6) (pow im 12))) (/ 1 (pow im 6)))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow im 6)) (* (pow re 6) (+ (* (pow re 6) (- (* 1/3 (/ (pow re 6) (pow im 18))) (* 1/2 (/ 1 (pow im 12))))) (/ 1 (pow im 6)))))))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (pow im 6)))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (+ (pow im 6) (pow re 6))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (log (pow im 10))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow im 10)) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow im 10)) (* (pow re 2) (- (* 1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow im 10)) (* (pow re 2) (- (* (pow re 2) (+ (* 5/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (pow im 10)))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -1 (* (pow im 8) (pow re 2))) (pow im 10))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* (pow re 2) (+ (* -1 (pow im 8)) (* (pow im 6) (pow re 2)))) (pow im 10))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* (pow re 2) (+ (* -1 (pow im 8)) (* (pow re 2) (+ (* (pow im 4) (pow re 2)) (pow im 6))))) (pow im 10))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (pow im 4)))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow im 4))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (+ (* (pow re 2) (- (pow re 2) (pow im 2))) (pow im 4))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (* -1 (* (pow im 2) (pow re 2)))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (* (pow re 2) (- (pow re 2) (pow im 2)))))
#s(approx (pow re 4) #s(hole binary64 (pow re 4)))
#s(approx (pow (* re im) 2) #s(hole binary64 (* (pow im 2) (pow re 2))))
#s(approx (* re im) #s(hole binary64 (* im re)))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (/ (pow (log (pow im 4)) 2) (log (pow im 10)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* (pow re 2) (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* (pow re 2) (- (+ (* (pow re 2) (- (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (log (pow im 10))))) (+ (* -1 (/ (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 4)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (/ 1 (* (pow im 6) (log (pow im 10))))))))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10)))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (pow (log (pow im 4)) 2)))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -2 (/ (* (pow re 2) (log (pow im 4))) (pow im 2))) (pow (log (pow im 4)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* (pow re 2) (+ (* -2 (/ (log (pow im 4)) (pow im 2))) (* (pow re 2) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4)))))) (pow (log (pow im 4)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* (pow re 2) (+ (* -2 (/ (log (pow im 4)) (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 4/3 (/ (log (pow im 4)) (pow im 6))) (/ 1 (pow im 6)))) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))))))) (pow (log (pow im 4)) 2))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (log (pow im 4))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow im 4)) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow im 4)) (* (pow re 2) (- (* 1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow im 4)) (* (pow re 2) (- (* (pow re 2) (+ (* 2/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (log 10) (log (pow im 10)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (* (pow re 2) (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (log 10) (log (pow im 10))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (log 10) (log (pow im 10))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (* (log 10) (log (pow im 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2))))))))) (* 1/2 (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (log 10) (log (pow im 10))))) (* (pow re 2) (+ (* 1/2 (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (* (log 10) (log (pow im 10)))))) (/ 1 (* (pow im 6) (* (log 10) (log (pow im 10)))))) (+ (* -1 (/ (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (* (log 10) (log (pow im 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2))))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))) (* (pow im 4) (log (pow im 10))))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (* (log 10) (log (pow im 10)))))) (* 5/3 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 2))))))))))) (* 1/2 (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (* (log 10) (log (pow im 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2)))))))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (log (pow im 10))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (* (pow re 2) (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (log (pow im 10)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (log (pow im 10)))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (log (pow im 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (pow (log (pow im 10)) 2)))))))) (* 1/2 (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2)))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (log (pow im 10)))) (* (pow re 2) (+ (* 1/2 (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (log (pow im 10))))) (/ 1 (* (pow im 6) (log (pow im 10))))) (+ (* -1 (/ (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (log (pow im 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (log (pow im 10))))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (log (pow im 10))))) (* 5/3 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 6) (pow (log (pow im 10)) 2)))))))))) (* 1/2 (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (log (pow im 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (pow (log (pow im 10)) 2))))))))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2))) (/ (* (pow re 2) (log (pow im 4))) (pow im 2)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2))) (* (pow re 2) (+ (* -1/2 (* (pow re 2) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))))) (/ (log (pow im 4)) (pow im 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2))) (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4)))) (* 1/2 (* (pow re 2) (- (+ (* 2 (/ (log (pow im 6)) (pow im 6))) (/ 1 (pow im 6))) (* 4/3 (/ (log (pow im 4)) (pow im 6)))))))) (/ (log (pow im 4)) (pow im 2)))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* 2 (/ (* (pow re 2) (log (pow im 4))) (pow im 2))) (pow (log (pow im 6)) 2)) (pow (log (pow im 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))))) (* -2 (/ (log (pow im 4)) (pow im 2))))) (pow (log (pow im 6)) 2)) (pow (log (pow im 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* (pow re 2) (- (* (pow re 2) (- (* (pow re 2) (- (+ (* 2 (/ (log (pow im 6)) (pow im 6))) (/ 1 (pow im 6))) (* 4/3 (/ (log (pow im 4)) (pow im 6))))) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))))) (* -2 (/ (log (pow im 4)) (pow im 2))))) (pow (log (pow im 6)) 2)) (pow (log (pow im 4)) 2))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))) (log 10))) (+ (* 1/2 (/ (- (/ (pow im 6) (log 10)) (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (log 10)))) (pow re 6))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re))))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/2 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re))))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/2 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re))))) (+ (* 1/2 (/ (- (pow im 6) (* 1/720 (+ (* -240 (pow im 6)) (* 720 (pow im 6))))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (* -4 (log (/ 1 re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 re))) (* -1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))) (+ (* -4 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 re))) (/ (pow im 6) (pow re 6))) (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (* -6 (log (/ 1 re)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (+ (* 1/3 (/ (pow im 18) (pow re 18))) (/ (pow im 6) (pow re 6)))))))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (pow re 6)))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (* (pow re 6) (+ 1 (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (* -4 (log (/ 1 re)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (pow re 4)))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (* (pow re 4) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (* (pow re 4) (- (+ 1 (/ (pow im 4) (pow re 4))) (/ (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 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))) (log 10))) (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ 1 re)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 9/250 (/ (pow im 4) (* (log 10) (log (/ 1 re)))))))) (pow re 4)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ 1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (log 10))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))))) (* (log 10) (log (/ 1 re))))) (* 6/5 (/ (pow im 6) (log 10)))))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re)))))) (* (log 10) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (log 10) (log (/ 1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (log 10) (log (/ 1 re))))) (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (log 10))))))) (pow re 6))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ 1 re)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 9/250 (/ (pow im 4) (* (log 10) (log (/ 1 re)))))))) (pow re 4))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re))))) (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re))))) (+ (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re))))))) (pow re 4)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re))))) (+ (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re)))) (+ (* 1/4500 (+ (* -240 (pow im 6)) (* 1440 (pow im 6)))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))))) (log (/ 1 re)))) (* 6/5 (pow im 6))))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re)))))) (log (/ 1 re)))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (log (/ 1 re)))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (log (/ 1 re)))) (* 1/2000 (+ (* -240 (pow im 6)) (* 1440 (pow im 6)))))))) (pow re 6))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re))))))) (pow re 4))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (* -4/25 (/ (pow im 2) (pow re 2)))) (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (* -9/25 (/ (pow im 2) (pow re 2))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ 1 re)))))))) (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ 1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ 1 re)))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ 1 re))))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))))) (* (pow re 6) (log (/ 1 re))))) (* 6/5 (/ (pow im 6) (pow re 6)))))))))) (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re)))))) (* (pow re 6) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (pow re 6) (log (/ 1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ 1 re)))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -18/5 (log (/ 1 re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -18/5 (log (/ 1 re))) (* 9/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (* -1 (/ (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re))))) (pow re 4)))) (* -9/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (* 6/5 (/ (pow im 6) (pow re 6)))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re)))))) (* (pow re 6) (log (/ 1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ 1 re)))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (* 36 (pow (log (/ 1 re)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ 1 re))) (pow re 6))) (* 36 (pow (log (/ 1 re)) 2)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ 1 re))) (pow re 6))) (+ (* 6 (/ (* (pow im 12) (log (/ 1 re))) (pow re 12))) (+ (* 36 (pow (log (/ 1 re)) 2)) (/ (pow im 12) (pow re 12)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ 1 re))) (pow re 6))) (+ (* -4 (/ (* (pow im 18) (log (/ 1 re))) (pow re 18))) (+ (* -1 (/ (pow im 18) (pow re 18))) (+ (* 6 (/ (* (pow im 12) (log (/ 1 re))) (pow re 12))) (+ (* 36 (pow (log (/ 1 re)) 2)) (/ (pow im 12) (pow re 12)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (* -6 (log (/ 1 re)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (+ (* 1/3 (/ (pow im 18) (pow re 18))) (/ (pow im 6) (pow re 6)))))))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (pow re 6)))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (* (pow re 6) (+ 1 (/ (pow im 6) (pow re 6))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (* -10 (log (/ 1 re)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (pow re 10)))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow re 10) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow re 10) (+ 1 (+ (* -1 (/ (pow im 2) (pow re 2))) (/ (pow im 4) (pow re 4)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow re 10) (+ 1 (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (/ (pow im 4) (pow re 4)) (/ (pow im 6) (pow re 6))))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (pow re 4)))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (* (pow re 4) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (* (pow re 4) (- (+ 1 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (pow re 4)))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (* (pow re 4) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -8/5 (log (/ 1 re)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 re))) (* -4/5 (/ (pow im 2) (pow re 2)))) (* -4/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ 1 re))))))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ 1 re))))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ 1 re))))) (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (pow re 6) (log (/ 1 re)))))))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ 1 re))))) (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))))) (* (pow re 6) (log (/ 1 re)))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (* 16 (pow (log (/ 1 re)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (* 16 (pow (log (/ 1 re)) 2)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* 16 (pow (log (/ 1 re)) 2)) (/ (pow im 4) (pow re 4)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* -1/12 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 6))) (+ (* -1/90 (/ (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))) (pow re 6))) (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* 16 (pow (log (/ 1 re)) 2)) (/ (pow im 4) (pow re 4)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* -4 (log (/ 1 re)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (* (log 10) (log (/ 1 re)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (* (log 10) (log (/ 1 re))))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2))))) (pow re 2))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (* (log 10) (log (/ 1 re))))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))))) (log (/ 1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2))))) (pow re 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (* (log 10) (log (/ 1 re))))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow im 6) (log (/ 1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (* (log 10) (log (/ 1 re))))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))))) (log (/ 1 re)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))))) (log (/ 1 re))))))) (log (/ 1 re))))))) (pow re 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))))) (log (/ 1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2))))) (pow re 2))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (log (/ 1 re))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (log (/ 1 re)))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2)))) (pow re 2))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (log (/ 1 re)))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2)))) (pow re 2)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (log (/ 1 re)))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow im 6) (log (/ 1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (log (/ 1 re)))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))))) (log (/ 1 re))))))) (log (/ 1 re))))))) (pow re 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2)))) (pow re 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (* 1/2 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (* 1/2 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (+ (* 1/2 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* 1/2 (/ (- (* -12 (* (pow im 6) (log (/ 1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (pow re 6))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (* 36 (pow (log (/ 1 re)) 2))) (* 16 (pow (log (/ 1 re)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -1 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (* 36 (pow (log (/ 1 re)) 2))) (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (* 16 (pow (log (/ 1 re)) 2))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -12 (/ (* (pow im 6) (log (/ 1 re))) (pow re 6))) (* 36 (pow (log (/ 1 re)) 2))) (+ (* -1/3 (/ (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* -1/12 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 6))) (+ (* -1/90 (/ (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))) (pow re 6))) (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* 16 (pow (log (/ 1 re)) 2)) (/ (pow im 4) (pow re 4))))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))) (log 10))) (+ (* 1/2 (/ (- (/ (pow im 6) (log 10)) (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (log 10)))) (pow re 6))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re))))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/2 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re))))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/2 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re))))) (+ (* 1/2 (/ (- (pow im 6) (* 1/720 (+ (* -240 (pow im 6)) (* 720 (pow im 6))))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (* -4 (log (/ -1 re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 re))) (* -1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))) (+ (* -4 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 re))) (/ (pow im 6) (pow re 6))) (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (* -6 (log (/ -1 re)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (+ (* 1/3 (/ (pow im 18) (pow re 18))) (/ (pow im 6) (pow re 6)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (* -4 (log (/ -1 re)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))) (log 10))) (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ -1 re)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 9/250 (/ (pow im 4) (* (log 10) (log (/ -1 re)))))))) (pow re 4)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ -1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (log 10))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))))) (* (log 10) (log (/ -1 re))))) (* 6/5 (/ (pow im 6) (log 10)))))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re)))))) (* (log 10) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (log 10) (log (/ -1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (log 10) (log (/ -1 re))))) (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (log 10))))))) (pow re 6))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ -1 re)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 9/250 (/ (pow im 4) (* (log 10) (log (/ -1 re)))))))) (pow re 4))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re))))) (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re))))) (+ (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re))))))) (pow re 4)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re))))) (+ (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re)))) (+ (* 1/4500 (+ (* -240 (pow im 6)) (* 1440 (pow im 6)))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))))) (log (/ -1 re)))) (* 6/5 (pow im 6))))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re)))))) (log (/ -1 re)))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (log (/ -1 re)))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (log (/ -1 re)))) (* 1/2000 (+ (* -240 (pow im 6)) (* 1440 (pow im 6)))))))) (pow re 6))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re))))))) (pow re 4))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (* -4/25 (/ (pow im 2) (pow re 2)))) (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (* -9/25 (/ (pow im 2) (pow re 2))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ -1 re)))))))) (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ -1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ -1 re)))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ -1 re))))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))))) (* (pow re 6) (log (/ -1 re))))) (* 6/5 (/ (pow im 6) (pow re 6)))))))))) (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re)))))) (* (pow re 6) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (pow re 6) (log (/ -1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ -1 re)))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -18/5 (log (/ -1 re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -18/5 (log (/ -1 re))) (* 9/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (* -1 (/ (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re))))) (pow re 4)))) (* -9/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (* 6/5 (/ (pow im 6) (pow re 6)))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re)))))) (* (pow re 6) (log (/ -1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ -1 re)))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (* 36 (pow (log (/ -1 re)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ -1 re))) (pow re 6))) (* 36 (pow (log (/ -1 re)) 2)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ -1 re))) (pow re 6))) (+ (* 6 (/ (* (pow im 12) (log (/ -1 re))) (pow re 12))) (+ (* 36 (pow (log (/ -1 re)) 2)) (/ (pow im 12) (pow re 12)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ -1 re))) (pow re 6))) (+ (* -4 (/ (* (pow im 18) (log (/ -1 re))) (pow re 18))) (+ (* -1 (/ (pow im 18) (pow re 18))) (+ (* 6 (/ (* (pow im 12) (log (/ -1 re))) (pow re 12))) (+ (* 36 (pow (log (/ -1 re)) 2)) (/ (pow im 12) (pow re 12)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (* -6 (log (/ -1 re)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (+ (* 1/3 (/ (pow im 18) (pow re 18))) (/ (pow im 6) (pow re 6)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (* -10 (log (/ -1 re)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -8/5 (log (/ -1 re)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 re))) (* -4/5 (/ (pow im 2) (pow re 2)))) (* -4/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ -1 re))))))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ -1 re))))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ -1 re))))) (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (pow re 6) (log (/ -1 re)))))))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ -1 re))))) (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))))) (* (pow re 6) (log (/ -1 re)))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (* 16 (pow (log (/ -1 re)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (* 16 (pow (log (/ -1 re)) 2)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* 16 (pow (log (/ -1 re)) 2)) (/ (pow im 4) (pow re 4)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* -1/12 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 6))) (+ (* -1/90 (/ (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))) (pow re 6))) (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* 16 (pow (log (/ -1 re)) 2)) (/ (pow im 4) (pow re 4)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* -4 (log (/ -1 re)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (* (log 10) (log (/ -1 re)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (* (log 10) (log (/ -1 re))))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2))))) (pow re 2))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (* (log 10) (log (/ -1 re))))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))))) (log (/ -1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2))))) (pow re 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (* (log 10) (log (/ -1 re))))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow im 6) (log (/ -1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (* (log 10) (log (/ -1 re))))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))))) (log (/ -1 re)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))))) (log (/ -1 re))))))) (log (/ -1 re))))))) (pow re 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))))) (log (/ -1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2))))) (pow re 2))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (log (/ -1 re))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (log (/ -1 re)))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2)))) (pow re 2))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (log (/ -1 re)))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2)))) (pow re 2)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (log (/ -1 re)))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow im 6) (log (/ -1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (log (/ -1 re)))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))))) (log (/ -1 re))))))) (log (/ -1 re))))))) (pow re 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2)))) (pow re 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (* 1/2 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (* 1/2 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (+ (* 1/2 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* 1/2 (/ (- (* -12 (* (pow im 6) (log (/ -1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (pow re 6))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (* 36 (pow (log (/ -1 re)) 2))) (* 16 (pow (log (/ -1 re)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -1 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (* 36 (pow (log (/ -1 re)) 2))) (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (* 16 (pow (log (/ -1 re)) 2))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -12 (/ (* (pow im 6) (log (/ -1 re))) (pow re 6))) (* 36 (pow (log (/ -1 re)) 2))) (+ (* -1/3 (/ (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* -1/12 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 6))) (+ (* -1/90 (/ (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))) (pow re 6))) (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* 16 (pow (log (/ -1 re)) 2)) (/ (pow im 4) (pow re 4))))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (log (pow re 6)) (log (pow re 4))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow re 6)) (log (pow re 4))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow re 6)) (log (pow re 4))) (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow re 6)) (log (pow re 4))) (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (log (pow re 6)) (log (pow re 4))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow re 6)) (log (pow re 4)))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow re 6)) (log (pow re 4)))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow re 6)) (log (pow re 4)))) (* (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (log (pow re 6)) (log (pow re 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow re 6)) (/ (pow im 2) (pow re 2))) (log (pow re 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow re 6)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (log (pow re 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow re 6)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (log (pow re 4)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (log (pow re 6))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow re 6)) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow re 6)) (* (pow im 6) (+ (* -1/2 (/ (pow im 6) (pow re 12))) (/ 1 (pow re 6)))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow re 6)) (* (pow im 6) (+ (* (pow im 6) (- (* 1/3 (/ (pow im 6) (pow re 18))) (* 1/2 (/ 1 (pow re 12))))) (/ 1 (pow re 6)))))))
#s(approx (pow im 6) #s(hole binary64 (pow im 6)))
#s(approx im #s(hole binary64 im))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (log (pow re 4))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow re 4)) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow re 4)) (* (pow im 2) (- (* 1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow re 4)) (* (pow im 2) (- (* (pow im 2) (+ (* 2/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow re 4))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1 (pow re 2)) (pow im 2))) (pow re 4))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (+ (* -1 (pow im 2)) (pow re 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (pow im 4) #s(hole binary64 (pow im 4)))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (* (pow im 2) (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))))))) (* 1/2 (/ (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))) (log 10))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))) (log 10))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2)))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 3))))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (/ 1 (* (pow re 4) (* (log 10) (log (pow re 10))))) (/ (log (pow re 4)) (* (pow re 4) (* (log 10) (log (pow re 10))))))))))) (* 1/2 (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))) (log 10))) (* (pow im 2) (+ (* 1/2 (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (* (log 10) (log (pow re 10)))))) (+ (* 5/3 (/ (pow (log (pow re 4)) 2) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (* (log 10) (log (pow re 10)))))) (/ 1 (* (pow re 6) (* (log 10) (log (pow re 10))))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 4))))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (* (log 10) (log (pow re 10)))))) (+ (* 5/3 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 2))))) (/ (pow (log (pow re 6)) 2) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 3)))))))))) (* 1/2 (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2)))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 3))))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (/ 1 (* (pow re 4) (* (log 10) (log (pow re 10))))) (/ (log (pow re 4)) (* (pow re 4) (* (log 10) (log (pow re 10)))))))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (* (pow im 2) (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))))) (* 1/2 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10)))))))))) (* 1/2 (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))) (* (pow im 2) (+ (* 1/2 (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 4)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (log (pow re 10))))) (/ 1 (* (pow re 6) (log (pow re 10)))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 4)))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 3))))))))) (* 1/2 (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow im 2) (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10)))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow im 2) (- (+ (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (* (pow im 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10)))))))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10)))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow im 2) (- (+ (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (* (pow im 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (* (pow im 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 4)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (log (pow re 10))))) (/ 1 (* (pow re 6) (log (pow re 10)))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 4)))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 3)))))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10)))))))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10)))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (/ (pow (log (pow re 6)) 2) (log (pow re 10)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (/ (* (pow im 2) (pow (log (pow re 6)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))) (/ (pow (log (pow re 6)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* (pow im 2) (- (* 2 (/ (log (pow re 6)) (* (pow re 6) (log (pow re 10))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 4)))) (+ (* 5/3 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 3))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (pow (log (pow re 6)) 2)))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* 2 (/ (* (pow im 6) (log (pow re 6))) (pow re 6))) (pow (log (pow re 6)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* (pow im 6) (+ (* 2 (/ (log (pow re 6)) (pow re 6))) (* (pow im 6) (+ (* -1 (/ (log (pow re 6)) (pow re 12))) (/ 1 (pow re 12)))))) (pow (log (pow re 6)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* (pow im 6) (+ (* 2 (/ (log (pow re 6)) (pow re 6))) (* (pow im 6) (+ (* -1 (/ (log (pow re 6)) (pow re 12))) (+ (* (pow im 6) (- (* 2/3 (/ (log (pow re 6)) (pow re 18))) (/ 1 (pow re 18)))) (/ 1 (pow re 12))))))) (pow (log (pow re 6)) 2))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (log (pow re 6))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow re 6)) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow re 6)) (* (pow im 6) (+ (* -1/2 (/ (pow im 6) (pow re 12))) (/ 1 (pow re 6)))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow re 6)) (* (pow im 6) (+ (* (pow im 6) (- (* 1/3 (/ (pow im 6) (pow re 18))) (* 1/2 (/ 1 (pow re 12))))) (/ 1 (pow re 6)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (log (pow re 10))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow re 10)) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow re 10)) (* (pow im 2) (- (* 1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow re 10)) (* (pow im 2) (- (* (pow im 2) (+ (* 5/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 8))) (pow re 10))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* (pow im 2) (+ (* -1 (pow re 8)) (* (pow im 2) (pow re 6)))) (pow re 10))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* (pow im 2) (+ (* -1 (pow re 8)) (* (pow im 2) (+ (* (pow im 2) (pow re 4)) (pow re 6))))) (pow re 10))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow re 4))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (+ (* (pow im 2) (- (pow im 2) (pow re 2))) (pow re 4))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow re 4))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (/ (pow (log (pow re 4)) 2) (log (pow re 10)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* (pow im 2) (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* (pow im 2) (- (+ (* (pow im 2) (- (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (log (pow re 10))))) (+ (* -1 (/ (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 4)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (/ 1 (* (pow re 6) (log (pow re 10))))))))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10)))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (pow (log (pow re 4)) 2)))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -2 (/ (* (pow im 2) (log (pow re 4))) (pow re 2))) (pow (log (pow re 4)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* (pow im 2) (+ (* -2 (/ (log (pow re 4)) (pow re 2))) (* (pow im 2) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4)))))) (pow (log (pow re 4)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* (pow im 2) (+ (* -2 (/ (log (pow re 4)) (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 4/3 (/ (log (pow re 4)) (pow re 6))) (/ 1 (pow re 6)))) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))))))) (pow (log (pow re 4)) 2))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (log (pow re 4))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow re 4)) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow re 4)) (* (pow im 2) (- (* 1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow re 4)) (* (pow im 2) (- (* (pow im 2) (+ (* 2/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (log 10) (log (pow re 10)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (* (pow im 2) (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (log 10) (log (pow re 10))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (log 10) (log (pow re 10))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (* (log 10) (log (pow re 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2))))))))) (* 1/2 (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (log 10) (log (pow re 10))))) (* (pow im 2) (+ (* 1/2 (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (* (log 10) (log (pow re 10)))))) (/ 1 (* (pow re 6) (* (log 10) (log (pow re 10)))))) (+ (* -1 (/ (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (* (log 10) (log (pow re 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2))))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))) (* (pow re 4) (log (pow re 10))))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (* (log 10) (log (pow re 10)))))) (* 5/3 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 2))))))))))) (* 1/2 (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (* (log 10) (log (pow re 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2)))))))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (log (pow re 10))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (* (pow im 2) (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (log (pow re 10)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (log (pow re 10)))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (log (pow re 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (pow (log (pow re 10)) 2)))))))) (* 1/2 (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2)))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (log (pow re 10)))) (* (pow im 2) (+ (* 1/2 (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (log (pow re 10))))) (/ 1 (* (pow re 6) (log (pow re 10))))) (+ (* -1 (/ (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (log (pow re 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (log (pow re 10))))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (log (pow re 10))))) (* 5/3 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 6) (pow (log (pow re 10)) 2)))))))))) (* 1/2 (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (log (pow re 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (pow (log (pow re 10)) 2))))))))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2))) (/ (* (pow im 2) (log (pow re 4))) (pow re 2)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2))) (* (pow im 2) (+ (* -1/2 (* (pow im 2) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))))) (/ (log (pow re 4)) (pow re 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2))) (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4)))) (* 1/2 (* (pow im 2) (- (+ (* 2 (/ (log (pow re 6)) (pow re 6))) (/ 1 (pow re 6))) (* 4/3 (/ (log (pow re 4)) (pow re 6)))))))) (/ (log (pow re 4)) (pow re 2)))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* 2 (/ (* (pow im 2) (log (pow re 4))) (pow re 2))) (pow (log (pow re 6)) 2)) (pow (log (pow re 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))))) (* -2 (/ (log (pow re 4)) (pow re 2))))) (pow (log (pow re 6)) 2)) (pow (log (pow re 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* (pow im 2) (- (* (pow im 2) (- (* (pow im 2) (- (+ (* 2 (/ (log (pow re 6)) (pow re 6))) (/ 1 (pow re 6))) (* 4/3 (/ (log (pow re 4)) (pow re 6))))) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))))) (* -2 (/ (log (pow re 4)) (pow re 2))))) (pow (log (pow re 6)) 2)) (pow (log (pow re 4)) 2))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))) (log 10))) (+ (* 1/2 (/ (- (/ (pow re 6) (log 10)) (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (log 10)))) (pow im 6))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im))))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/2 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im))))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/2 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im))))) (+ (* 1/2 (/ (- (pow re 6) (* 1/720 (+ (* -240 (pow re 6)) (* 720 (pow re 6))))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (* -4 (log (/ 1 im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 im))) (* -1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))) (+ (* -4 (log (/ 1 im))) (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 im))) (/ (pow re 6) (pow im 6))) (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (* -6 (log (/ 1 im)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (+ (* 1/3 (/ (pow re 18) (pow im 18))) (/ (pow re 6) (pow im 6)))))))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (* (pow im 6) (+ 1 (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (* -4 (log (/ 1 im)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (* (pow im 4) (+ 1 (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (* (pow im 4) (+ 1 (+ (* -1 (/ (pow re 2) (pow im 2))) (/ (pow re 4) (pow im 4)))))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (- (/ (pow re 2) (pow im 2)) 1))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))) (log 10))) (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ 1 im)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 9/250 (/ (pow re 4) (* (log 10) (log (/ 1 im)))))))) (pow im 4)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ 1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (log 10))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))))) (* (log 10) (log (/ 1 im))))) (* 6/5 (/ (pow re 6) (log 10)))))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im)))))) (* (log 10) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (log 10) (log (/ 1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (log 10) (log (/ 1 im))))) (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (log 10))))))) (pow im 6))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ 1 im)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 9/250 (/ (pow re 4) (* (log 10) (log (/ 1 im)))))))) (pow im 4))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im))))) (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im))))) (+ (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im))))))) (pow im 4)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im))))) (+ (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im)))) (+ (* 1/4500 (+ (* -240 (pow re 6)) (* 1440 (pow re 6)))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))))) (log (/ 1 im)))) (* 6/5 (pow re 6))))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im)))))) (log (/ 1 im)))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (log (/ 1 im)))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (log (/ 1 im)))) (* 1/2000 (+ (* -240 (pow re 6)) (* 1440 (pow re 6)))))))) (pow im 6))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im))))))) (pow im 4))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (* -4/25 (/ (pow re 2) (pow im 2)))) (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (* -9/25 (/ (pow re 2) (pow im 2))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ 1 im)))))))) (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ 1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ 1 im)))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ 1 im))))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))))) (* (pow im 6) (log (/ 1 im))))) (* 6/5 (/ (pow re 6) (pow im 6)))))))))) (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im)))))) (* (pow im 6) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (pow im 6) (log (/ 1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ 1 im)))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -18/5 (log (/ 1 im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -18/5 (log (/ 1 im))) (* 9/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (* -1 (/ (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im))))) (pow im 4)))) (* -9/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (* 6/5 (/ (pow re 6) (pow im 6)))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im)))))) (* (pow im 6) (log (/ 1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ 1 im)))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (* 36 (pow (log (/ 1 im)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ 1 im))) (pow im 6))) (* 36 (pow (log (/ 1 im)) 2)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ 1 im))) (pow im 6))) (+ (* 6 (/ (* (pow re 12) (log (/ 1 im))) (pow im 12))) (+ (* 36 (pow (log (/ 1 im)) 2)) (/ (pow re 12) (pow im 12)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ 1 im))) (pow im 6))) (+ (* -4 (/ (* (pow re 18) (log (/ 1 im))) (pow im 18))) (+ (* -1 (/ (pow re 18) (pow im 18))) (+ (* 6 (/ (* (pow re 12) (log (/ 1 im))) (pow im 12))) (+ (* 36 (pow (log (/ 1 im)) 2)) (/ (pow re 12) (pow im 12)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (* -6 (log (/ 1 im)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (+ (* 1/3 (/ (pow re 18) (pow im 18))) (/ (pow re 6) (pow im 6)))))))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (* (pow im 6) (+ 1 (/ (pow re 6) (pow im 6))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (* -10 (log (/ 1 im)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow im 10) (+ 1 (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow im 10) (+ 1 (+ (* -1 (/ (pow re 2) (pow im 2))) (/ (pow re 4) (pow im 4)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow im 10) (+ 1 (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (/ (pow re 4) (pow im 4)) (/ (pow re 6) (pow im 6))))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (* (pow im 4) (+ 1 (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (* (pow im 4) (- (+ 1 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (* (pow im 2) (- (/ (pow re 4) (pow im 2)) (pow re 2)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -8/5 (log (/ 1 im)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 im))) (* -4/5 (/ (pow re 2) (pow im 2)))) (* -4/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ 1 im))))))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ 1 im))))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ 1 im))))) (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (pow im 6) (log (/ 1 im)))))))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ 1 im))))) (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))))) (* (pow im 6) (log (/ 1 im)))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (* 16 (pow (log (/ 1 im)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (* 16 (pow (log (/ 1 im)) 2)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* 16 (pow (log (/ 1 im)) 2)) (/ (pow re 4) (pow im 4)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* -1/12 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 6))) (+ (* -1/90 (/ (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))) (pow im 6))) (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* 16 (pow (log (/ 1 im)) 2)) (/ (pow re 4) (pow im 4)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* -4 (log (/ 1 im)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (* (log 10) (log (/ 1 im)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (* (log 10) (log (/ 1 im))))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2))))) (pow im 2))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (* (log 10) (log (/ 1 im))))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))))) (log (/ 1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2))))) (pow im 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (* (log 10) (log (/ 1 im))))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow re 6) (log (/ 1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (* (log 10) (log (/ 1 im))))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))))) (log (/ 1 im)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))))) (log (/ 1 im))))))) (log (/ 1 im))))))) (pow im 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))))) (log (/ 1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2))))) (pow im 2))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (log (/ 1 im))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (log (/ 1 im)))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2)))) (pow im 2))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (log (/ 1 im)))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2)))) (pow im 2)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (log (/ 1 im)))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow re 6) (log (/ 1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (log (/ 1 im)))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))))) (log (/ 1 im))))))) (log (/ 1 im))))))) (pow im 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2)))) (pow im 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (* 1/2 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (* 1/2 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (+ (* 1/2 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* 1/2 (/ (- (* -12 (* (pow re 6) (log (/ 1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (pow im 6))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (* 36 (pow (log (/ 1 im)) 2))) (* 16 (pow (log (/ 1 im)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -1 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (* 36 (pow (log (/ 1 im)) 2))) (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (* 16 (pow (log (/ 1 im)) 2))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -12 (/ (* (pow re 6) (log (/ 1 im))) (pow im 6))) (* 36 (pow (log (/ 1 im)) 2))) (+ (* -1/3 (/ (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* -1/12 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 6))) (+ (* -1/90 (/ (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))) (pow im 6))) (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* 16 (pow (log (/ 1 im)) 2)) (/ (pow re 4) (pow im 4))))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))) (log 10))) (+ (* 1/2 (/ (- (/ (pow re 6) (log 10)) (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (log 10)))) (pow im 6))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im))))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/2 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im))))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/2 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im))))) (+ (* 1/2 (/ (- (pow re 6) (* 1/720 (+ (* -240 (pow re 6)) (* 720 (pow re 6))))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (* -4 (log (/ -1 im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 im))) (* -1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))) (+ (* -4 (log (/ -1 im))) (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 im))) (/ (pow re 6) (pow im 6))) (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (* -6 (log (/ -1 im)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (+ (* 1/3 (/ (pow re 18) (pow im 18))) (/ (pow re 6) (pow im 6)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (* -4 (log (/ -1 im)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))) (log 10))) (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ -1 im)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 9/250 (/ (pow re 4) (* (log 10) (log (/ -1 im)))))))) (pow im 4)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ -1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (log 10))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))))) (* (log 10) (log (/ -1 im))))) (* 6/5 (/ (pow re 6) (log 10)))))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im)))))) (* (log 10) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (log 10) (log (/ -1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (log 10) (log (/ -1 im))))) (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (log 10))))))) (pow im 6))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ -1 im)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 9/250 (/ (pow re 4) (* (log 10) (log (/ -1 im)))))))) (pow im 4))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im))))) (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im))))) (+ (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im))))))) (pow im 4)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im))))) (+ (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im)))) (+ (* 1/4500 (+ (* -240 (pow re 6)) (* 1440 (pow re 6)))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))))) (log (/ -1 im)))) (* 6/5 (pow re 6))))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im)))))) (log (/ -1 im)))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (log (/ -1 im)))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (log (/ -1 im)))) (* 1/2000 (+ (* -240 (pow re 6)) (* 1440 (pow re 6)))))))) (pow im 6))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im))))))) (pow im 4))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (* -4/25 (/ (pow re 2) (pow im 2)))) (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (* -9/25 (/ (pow re 2) (pow im 2))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ -1 im)))))))) (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ -1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ -1 im)))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ -1 im))))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))))) (* (pow im 6) (log (/ -1 im))))) (* 6/5 (/ (pow re 6) (pow im 6)))))))))) (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im)))))) (* (pow im 6) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (pow im 6) (log (/ -1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ -1 im)))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -18/5 (log (/ -1 im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -18/5 (log (/ -1 im))) (* 9/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (* -1 (/ (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im))))) (pow im 4)))) (* -9/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (* 6/5 (/ (pow re 6) (pow im 6)))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im)))))) (* (pow im 6) (log (/ -1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ -1 im)))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (* 36 (pow (log (/ -1 im)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ -1 im))) (pow im 6))) (* 36 (pow (log (/ -1 im)) 2)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ -1 im))) (pow im 6))) (+ (* 6 (/ (* (pow re 12) (log (/ -1 im))) (pow im 12))) (+ (* 36 (pow (log (/ -1 im)) 2)) (/ (pow re 12) (pow im 12)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ -1 im))) (pow im 6))) (+ (* -4 (/ (* (pow re 18) (log (/ -1 im))) (pow im 18))) (+ (* -1 (/ (pow re 18) (pow im 18))) (+ (* 6 (/ (* (pow re 12) (log (/ -1 im))) (pow im 12))) (+ (* 36 (pow (log (/ -1 im)) 2)) (/ (pow re 12) (pow im 12)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (* -6 (log (/ -1 im)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (+ (* 1/3 (/ (pow re 18) (pow im 18))) (/ (pow re 6) (pow im 6)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (* -10 (log (/ -1 im)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -8/5 (log (/ -1 im)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 im))) (* -4/5 (/ (pow re 2) (pow im 2)))) (* -4/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ -1 im))))))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ -1 im))))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ -1 im))))) (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (pow im 6) (log (/ -1 im)))))))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ -1 im))))) (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))))) (* (pow im 6) (log (/ -1 im)))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (* 16 (pow (log (/ -1 im)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (* 16 (pow (log (/ -1 im)) 2)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* 16 (pow (log (/ -1 im)) 2)) (/ (pow re 4) (pow im 4)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* -1/12 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 6))) (+ (* -1/90 (/ (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))) (pow im 6))) (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* 16 (pow (log (/ -1 im)) 2)) (/ (pow re 4) (pow im 4)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* -4 (log (/ -1 im)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (* (log 10) (log (/ -1 im)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (* (log 10) (log (/ -1 im))))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2))))) (pow im 2))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (* (log 10) (log (/ -1 im))))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))))) (log (/ -1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2))))) (pow im 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (* (log 10) (log (/ -1 im))))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow re 6) (log (/ -1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (* (log 10) (log (/ -1 im))))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))))) (log (/ -1 im)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))))) (log (/ -1 im))))))) (log (/ -1 im))))))) (pow im 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))))) (log (/ -1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2))))) (pow im 2))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (log (/ -1 im))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (log (/ -1 im)))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2)))) (pow im 2))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (log (/ -1 im)))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2)))) (pow im 2)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (log (/ -1 im)))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow re 6) (log (/ -1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (log (/ -1 im)))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))))) (log (/ -1 im))))))) (log (/ -1 im))))))) (pow im 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2)))) (pow im 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (* 1/2 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (* 1/2 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (+ (* 1/2 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* 1/2 (/ (- (* -12 (* (pow re 6) (log (/ -1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (pow im 6))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (* 36 (pow (log (/ -1 im)) 2))) (* 16 (pow (log (/ -1 im)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -1 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (* 36 (pow (log (/ -1 im)) 2))) (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (* 16 (pow (log (/ -1 im)) 2))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -12 (/ (* (pow re 6) (log (/ -1 im))) (pow im 6))) (* 36 (pow (log (/ -1 im)) 2))) (+ (* -1/3 (/ (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* -1/12 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 6))) (+ (* -1/90 (/ (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))) (pow im 6))) (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* 16 (pow (log (/ -1 im)) 2)) (/ (pow re 4) (pow im 4))))))))))
Calls

6 calls:

TimeVariablePointExpression
59.0ms
im
@0
((/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (log (+ (pow im 6) (pow re 6))) (+ (pow im 6) (pow re 6)) (pow im 6) im 6 (pow re 6) re (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (* re re) (- (* re re) (* im im)) (* im im) (pow im 4) 4 (log 10) 10 (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow re 6) (pow im 6))) 2) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) 2 (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (- (pow re 4) (pow (* re im) 2)) (pow re 4) (pow (* re im) 2) (* re im) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)))
55.0ms
re
@inf
((/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (log (+ (pow im 6) (pow re 6))) (+ (pow im 6) (pow re 6)) (pow im 6) im 6 (pow re 6) re (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (* re re) (- (* re re) (* im im)) (* im im) (pow im 4) 4 (log 10) 10 (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow re 6) (pow im 6))) 2) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) 2 (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (- (pow re 4) (pow (* re im) 2)) (pow re 4) (pow (* re im) 2) (* re im) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)))
55.0ms
im
@inf
((/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (log (+ (pow im 6) (pow re 6))) (+ (pow im 6) (pow re 6)) (pow im 6) im 6 (pow re 6) re (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (* re re) (- (* re re) (* im im)) (* im im) (pow im 4) 4 (log 10) 10 (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow re 6) (pow im 6))) 2) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) 2 (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (- (pow re 4) (pow (* re im) 2)) (pow re 4) (pow (* re im) 2) (* re im) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)))
53.0ms
re
@0
((/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (log (+ (pow im 6) (pow re 6))) (+ (pow im 6) (pow re 6)) (pow im 6) im 6 (pow re 6) re (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (* re re) (- (* re re) (* im im)) (* im im) (pow im 4) 4 (log 10) 10 (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow re 6) (pow im 6))) 2) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) 2 (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (- (pow re 4) (pow (* re im) 2)) (pow re 4) (pow (* re im) 2) (* re im) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)))
26.0ms
re
@-inf
((/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (log (+ (pow im 6) (pow re 6))) (+ (pow im 6) (pow re 6)) (pow im 6) im 6 (pow re 6) re (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (* re re) (- (* re re) (* im im)) (* im im) (pow im 4) 4 (log 10) 10 (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow re 6) (pow im 6))) 2) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) 2 (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (- (pow re 4) (pow (* re im) 2)) (pow re 4) (pow (* re im) 2) (* re im) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)))

rewrite362.0ms (15.7%)

Memory
-20.6MiB live, 695.1MiB allocated; 52ms collecting garbage
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0316653964
0324750809
01130749067
Stop Event
1×iter-limit
1×node-limit
1×iter-limit
Counts
564 → 598
Calls
Call 1
Inputs
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64))))))
#s(literal 1/2 binary64)
(-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))))
(log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))
(+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))
(pow.f64 im #s(literal 6 binary64))
im
#s(literal 6 binary64)
(pow.f64 re #s(literal 6 binary64))
re
(log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64))))
(fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))
(*.f64 re re)
(-.f64 (*.f64 re re) (*.f64 im im))
(*.f64 im im)
(pow.f64 im #s(literal 4 binary64))
#s(literal 4 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1/2 binary64) (-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))))
(-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64))
(log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))
(+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))
#s(literal 2 binary64)
(log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))
(*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 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))))
(-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))
(pow.f64 re #s(literal 4 binary64))
(pow.f64 (*.f64 re im) #s(literal 2 binary64))
(*.f64 re im)
(/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(pow.f64 (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))))) #s(literal 2 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)))))
(/.f64 (/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64))
(-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64)))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (log (pow im 6)) (log (pow im 4))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow im 6)) (log (pow im 4))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow im 6)) (log (pow im 4))) (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow im 6)) (log (pow im 4))) (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (log (pow im 6)) (log (pow im 4))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow im 6)) (log (pow im 4)))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow im 6)) (log (pow im 4)))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow im 6)) (log (pow im 4)))) (* (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (log (pow im 6)) (log (pow im 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow im 6)) (/ (pow re 2) (pow im 2))) (log (pow im 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow im 6)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (log (pow im 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow im 6)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (log (pow im 4)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (log (pow im 6))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow im 6)) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow im 6)) (* (pow re 6) (+ (* -1/2 (/ (pow re 6) (pow im 12))) (/ 1 (pow im 6)))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow im 6)) (* (pow re 6) (+ (* (pow re 6) (- (* 1/3 (/ (pow re 6) (pow im 18))) (* 1/2 (/ 1 (pow im 12))))) (/ 1 (pow im 6)))))))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (pow im 6)))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (+ (pow im 6) (pow re 6))))
#s(approx (pow re 6) #s(hole binary64 (pow re 6)))
#s(approx re #s(hole binary64 re))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (log (pow im 4))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow im 4)) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow im 4)) (* (pow re 2) (- (* 1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow im 4)) (* (pow re 2) (- (* (pow re 2) (+ (* 2/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (pow im 4)))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow im 4))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1 (pow im 2)) (pow re 2))) (pow im 4))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* -1 (pow im 2))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (- (pow re 2) (pow im 2))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (* (pow re 2) (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))))))) (* 1/2 (/ (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))) (log 10))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))) (log 10))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2)))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 3))))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (/ 1 (* (pow im 4) (* (log 10) (log (pow im 10))))) (/ (log (pow im 4)) (* (pow im 4) (* (log 10) (log (pow im 10))))))))))) (* 1/2 (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))) (log 10))) (* (pow re 2) (+ (* 1/2 (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (* (log 10) (log (pow im 10)))))) (+ (* 5/3 (/ (pow (log (pow im 4)) 2) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (* (log 10) (log (pow im 10)))))) (/ 1 (* (pow im 6) (* (log 10) (log (pow im 10))))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 4))))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (* (log 10) (log (pow im 10)))))) (+ (* 5/3 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 2))))) (/ (pow (log (pow im 6)) 2) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 3)))))))))) (* 1/2 (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2)))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 3))))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2))))) (+ (/ 1 (* (pow im 4) (* (log 10) (log (pow im 10))))) (/ (log (pow im 4)) (* (pow im 4) (* (log 10) (log (pow im 10)))))))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (* (pow re 2) (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))))) (* 1/2 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10)))))))))) (* 1/2 (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))) (* (pow re 2) (+ (* 1/2 (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 4)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (log (pow im 10))))) (/ 1 (* (pow im 6) (log (pow im 10)))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 4)))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 3))))))))) (* 1/2 (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (/ (pow (log (pow im 6)) 2) (log (pow im 10))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow re 2) (- (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10)))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow re 2) (- (+ (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (* (pow re 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10)))))))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10)))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow re 2) (- (+ (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))) (* (pow re 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (* (pow re 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 4)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (log (pow im 10))))) (/ 1 (* (pow im 6) (log (pow im 10)))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 4)))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 3)))))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10)))))))))) (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10)))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (/ (pow (log (pow im 6)) 2) (log (pow im 10)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (/ (* (pow re 2) (pow (log (pow im 6)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))) (/ (pow (log (pow im 6)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (* (pow re 2) (- (* (pow re 2) (- (* 2 (/ (log (pow im 6)) (* (pow im 6) (log (pow im 10))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 4)))) (+ (* 5/3 (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (/ (pow (log (pow im 6)) 2) (* (pow im 6) (pow (log (pow im 10)) 3))))))) (+ (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 3)))) (* 1/2 (/ (pow (log (pow im 6)) 2) (* (pow im 4) (pow (log (pow im 10)) 2))))))) (* -1 (/ (pow (log (pow im 6)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 6)) 2) (log (pow im 10))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (pow (log (pow im 6)) 2)))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* 2 (/ (* (pow re 6) (log (pow im 6))) (pow im 6))) (pow (log (pow im 6)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* (pow re 6) (+ (* 2 (/ (log (pow im 6)) (pow im 6))) (* (pow re 6) (+ (* -1 (/ (log (pow im 6)) (pow im 12))) (/ 1 (pow im 12)))))) (pow (log (pow im 6)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* (pow re 6) (+ (* 2 (/ (log (pow im 6)) (pow im 6))) (* (pow re 6) (+ (* -1 (/ (log (pow im 6)) (pow im 12))) (+ (* (pow re 6) (- (* 2/3 (/ (log (pow im 6)) (pow im 18))) (/ 1 (pow im 18)))) (/ 1 (pow im 12))))))) (pow (log (pow im 6)) 2))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (log (pow im 6))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow im 6)) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow im 6)) (* (pow re 6) (+ (* -1/2 (/ (pow re 6) (pow im 12))) (/ 1 (pow im 6)))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow im 6)) (* (pow re 6) (+ (* (pow re 6) (- (* 1/3 (/ (pow re 6) (pow im 18))) (* 1/2 (/ 1 (pow im 12))))) (/ 1 (pow im 6)))))))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (pow im 6)))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (+ (pow im 6) (pow re 6))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (log (pow im 10))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow im 10)) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow im 10)) (* (pow re 2) (- (* 1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow im 10)) (* (pow re 2) (- (* (pow re 2) (+ (* 5/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (pow im 10)))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -1 (* (pow im 8) (pow re 2))) (pow im 10))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* (pow re 2) (+ (* -1 (pow im 8)) (* (pow im 6) (pow re 2)))) (pow im 10))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* (pow re 2) (+ (* -1 (pow im 8)) (* (pow re 2) (+ (* (pow im 4) (pow re 2)) (pow im 6))))) (pow im 10))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (pow im 4)))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow im 4))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (+ (* (pow re 2) (- (pow re 2) (pow im 2))) (pow im 4))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (* -1 (* (pow im 2) (pow re 2)))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (* (pow re 2) (- (pow re 2) (pow im 2)))))
#s(approx (pow re 4) #s(hole binary64 (pow re 4)))
#s(approx (pow (* re im) 2) #s(hole binary64 (* (pow im 2) (pow re 2))))
#s(approx (* re im) #s(hole binary64 (* im re)))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (/ (pow (log (pow im 4)) 2) (log (pow im 10)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* (pow re 2) (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow re 2) (- (+ (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* (pow re 2) (- (+ (* (pow re 2) (- (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (log (pow im 10))))) (+ (* -1 (/ (- (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (log (pow im 10))))) (+ (* 5/3 (/ (pow (log (pow im 4)) 2) (* (pow im 6) (pow (log (pow im 10)) 2)))) (/ 1 (* (pow im 6) (log (pow im 10))))))))) (+ (/ 1 (* (pow im 4) (log (pow im 10)))) (/ (log (pow im 4)) (* (pow im 4) (log (pow im 10)))))) (+ (* -1 (/ (- (* -2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (pow (log (pow im 4)) 2) (* (pow im 4) (pow (log (pow im 10)) 2)))))))) (* -1 (/ (pow (log (pow im 4)) 2) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (/ (pow (log (pow im 4)) 2) (log (pow im 10))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (pow (log (pow im 4)) 2)))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -2 (/ (* (pow re 2) (log (pow im 4))) (pow im 2))) (pow (log (pow im 4)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* (pow re 2) (+ (* -2 (/ (log (pow im 4)) (pow im 2))) (* (pow re 2) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4)))))) (pow (log (pow im 4)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* (pow re 2) (+ (* -2 (/ (log (pow im 4)) (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 4/3 (/ (log (pow im 4)) (pow im 6))) (/ 1 (pow im 6)))) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))))))) (pow (log (pow im 4)) 2))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (log (pow im 4))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow im 4)) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow im 4)) (* (pow re 2) (- (* 1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow im 4)) (* (pow re 2) (- (* (pow re 2) (+ (* 2/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (log 10) (log (pow im 10)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (* (pow re 2) (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (log 10) (log (pow im 10))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (log 10) (log (pow im 10))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (* (log 10) (log (pow im 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2))))))))) (* 1/2 (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (log 10) (log (pow im 10))))) (* (pow re 2) (+ (* 1/2 (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2))))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (* (log 10) (log (pow im 10)))))) (/ 1 (* (pow im 6) (* (log 10) (log (pow im 10)))))) (+ (* -1 (/ (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (* (log 10) (log (pow im 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2))))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))) (* (pow im 4) (log (pow im 10))))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (* (log 10) (log (pow im 10)))))) (* 5/3 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 6) (* (log 10) (pow (log (pow im 10)) 2))))))))))) (* 1/2 (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (* (log 10) (log (pow im 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (* (log 10) (log (pow im 10)))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (* (log 10) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (* (log 10) (pow (log (pow im 10)) 2)))))))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (log (pow im 10))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (* (pow re 2) (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (log (pow im 10)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (log (pow im 10)))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (log (pow im 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (pow (log (pow im 10)) 2)))))))) (* 1/2 (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2)))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (log (pow im 10)))) (* (pow re 2) (+ (* 1/2 (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2)))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (- (+ (* 2 (/ (log (pow im 6)) (* (pow im 6) (log (pow im 10))))) (/ 1 (* (pow im 6) (log (pow im 10))))) (+ (* -1 (/ (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (log (pow im 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (pow (log (pow im 10)) 2)))))) (* (pow im 2) (log (pow im 10))))) (+ (* 1/2 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 4) (log (pow im 10))))) (+ (* 4/3 (/ (log (pow im 4)) (* (pow im 6) (log (pow im 10))))) (* 5/3 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 6) (pow (log (pow im 10)) 2)))))))))) (* 1/2 (- (* -1 (/ (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))) (log (pow im 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow im 4)) (* (pow im 2) (log (pow im 10))))) (* -1 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 2) (pow (log (pow im 10)) 2))))) (* (pow im 2) (log (pow im 10))))) (* 1/2 (/ (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)) (* (pow im 4) (pow (log (pow im 10)) 2))))))))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2))) (/ (* (pow re 2) (log (pow im 4))) (pow im 2)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2))) (* (pow re 2) (+ (* -1/2 (* (pow re 2) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))))) (/ (log (pow im 4)) (pow im 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2))) (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4)))) (* 1/2 (* (pow re 2) (- (+ (* 2 (/ (log (pow im 6)) (pow im 6))) (/ 1 (pow im 6))) (* 4/3 (/ (log (pow im 4)) (pow im 6)))))))) (/ (log (pow im 4)) (pow im 2)))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (pow (log (pow im 6)) 2) (pow (log (pow im 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* 2 (/ (* (pow re 2) (log (pow im 4))) (pow im 2))) (pow (log (pow im 6)) 2)) (pow (log (pow im 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))))) (* -2 (/ (log (pow im 4)) (pow im 2))))) (pow (log (pow im 6)) 2)) (pow (log (pow im 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* (pow re 2) (- (* (pow re 2) (- (* (pow re 2) (- (+ (* 2 (/ (log (pow im 6)) (pow im 6))) (/ 1 (pow im 6))) (* 4/3 (/ (log (pow im 4)) (pow im 6))))) (+ (/ 1 (pow im 4)) (/ (log (pow im 4)) (pow im 4))))) (* -2 (/ (log (pow im 4)) (pow im 2))))) (pow (log (pow im 6)) 2)) (pow (log (pow im 4)) 2))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))) (log 10))) (+ (* 1/2 (/ (- (/ (pow im 6) (log 10)) (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (log 10)))) (pow re 6))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re))))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/2 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re))))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/2 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re))))) (+ (* 1/2 (/ (- (pow im 6) (* 1/720 (+ (* -240 (pow im 6)) (* 720 (pow im 6))))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (* -6 (log (/ 1 re))) (* -4 (log (/ 1 re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (* -4 (log (/ 1 re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 re))) (* -1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))) (+ (* -4 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 re))) (/ (pow im 6) (pow re 6))) (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (* -6 (log (/ 1 re)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (+ (* 1/3 (/ (pow im 18) (pow re 18))) (/ (pow im 6) (pow re 6)))))))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (pow re 6)))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (* (pow re 6) (+ 1 (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (* -4 (log (/ 1 re)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (pow re 4)))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (* (pow re 4) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (* (pow re 4) (- (+ 1 (/ (pow im 4) (pow re 4))) (/ (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 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))) (log 10))) (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ 1 re)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 9/250 (/ (pow im 4) (* (log 10) (log (/ 1 re)))))))) (pow re 4)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ 1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (log 10))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))))) (* (log 10) (log (/ 1 re))))) (* 6/5 (/ (pow im 6) (log 10)))))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re)))))) (* (log 10) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (log 10) (log (/ 1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (log 10) (log (/ 1 re))))) (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (log 10))))))) (pow re 6))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ 1 re)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 9/250 (/ (pow im 4) (* (log 10) (log (/ 1 re)))))))) (pow re 4))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re))))) (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re))))) (+ (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re))))))) (pow re 4)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re))))) (+ (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re)))) (+ (* 1/4500 (+ (* -240 (pow im 6)) (* 1440 (pow im 6)))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))))) (log (/ 1 re)))) (* 6/5 (pow im 6))))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re)))))) (log (/ 1 re)))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (log (/ 1 re)))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (log (/ 1 re)))) (* 1/2000 (+ (* -240 (pow im 6)) (* 1440 (pow im 6)))))))) (pow re 6))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re))))))) (pow re 4))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (* -18/5 (log (/ 1 re))) (* -8/5 (log (/ 1 re))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (* -4/25 (/ (pow im 2) (pow re 2)))) (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (* -9/25 (/ (pow im 2) (pow re 2))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ 1 re)))))))) (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ 1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ 1 re)))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ 1 re))))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))))) (* (pow re 6) (log (/ 1 re))))) (* 6/5 (/ (pow im 6) (pow re 6)))))))))) (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re)))))) (* (pow re 6) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ 1 re))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (pow re 6) (log (/ 1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ 1 re)))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -18/5 (log (/ 1 re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -18/5 (log (/ 1 re))) (* 9/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (* -1 (/ (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re))))) (pow re 4)))) (* -9/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 re))) (* 6/5 (/ (pow im 6) (pow re 6)))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ 1 re)))))) (* (pow re 6) (log (/ 1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ 1 re)))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (* 36 (pow (log (/ 1 re)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ 1 re))) (pow re 6))) (* 36 (pow (log (/ 1 re)) 2)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ 1 re))) (pow re 6))) (+ (* 6 (/ (* (pow im 12) (log (/ 1 re))) (pow re 12))) (+ (* 36 (pow (log (/ 1 re)) 2)) (/ (pow im 12) (pow re 12)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ 1 re))) (pow re 6))) (+ (* -4 (/ (* (pow im 18) (log (/ 1 re))) (pow re 18))) (+ (* -1 (/ (pow im 18) (pow re 18))) (+ (* 6 (/ (* (pow im 12) (log (/ 1 re))) (pow re 12))) (+ (* 36 (pow (log (/ 1 re)) 2)) (/ (pow im 12) (pow re 12)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (* -6 (log (/ 1 re)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (+ (* 1/3 (/ (pow im 18) (pow re 18))) (/ (pow im 6) (pow re 6)))))))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (pow re 6)))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (* (pow re 6) (+ 1 (/ (pow im 6) (pow re 6))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (* -10 (log (/ 1 re)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (pow re 10)))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow re 10) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow re 10) (+ 1 (+ (* -1 (/ (pow im 2) (pow re 2))) (/ (pow im 4) (pow re 4)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow re 10) (+ 1 (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (/ (pow im 4) (pow re 4)) (/ (pow im 6) (pow re 6))))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (pow re 4)))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (* (pow re 4) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (* (pow re 4) (- (+ 1 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (pow re 4)))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (* (pow re 4) (+ 1 (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -8/5 (log (/ 1 re)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 re))) (* -4/5 (/ (pow im 2) (pow re 2)))) (* -4/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ 1 re))))))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ 1 re))))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ 1 re))))) (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (pow re 6) (log (/ 1 re)))))))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ 1 re))))) (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ 1 re))))))) (* (pow re 6) (log (/ 1 re)))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (* 16 (pow (log (/ 1 re)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (* 16 (pow (log (/ 1 re)) 2)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* 16 (pow (log (/ 1 re)) 2)) (/ (pow im 4) (pow re 4)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* -1/12 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 6))) (+ (* -1/90 (/ (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))) (pow re 6))) (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* 16 (pow (log (/ 1 re)) 2)) (/ (pow im 4) (pow re 4)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* -4 (log (/ 1 re)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (* (log 10) (log (/ 1 re)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (* (log 10) (log (/ 1 re))))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2))))) (pow re 2))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (* (log 10) (log (/ 1 re))))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))))) (log (/ 1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2))))) (pow re 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (* (log 10) (log (/ 1 re))))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow im 6) (log (/ 1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (* (log 10) (log (/ 1 re))))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))))) (log (/ 1 re)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))))) (log (/ 1 re))))))) (log (/ 1 re))))))) (pow re 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ 1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2)))))) (log (/ 1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* (log 10) (pow (log (/ 1 re)) 2))))) (pow re 2))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (log (/ 1 re))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (log (/ 1 re)))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2)))) (pow re 2))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (log (/ 1 re)))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2)))) (pow re 2)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))) (log (/ 1 re)))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow im 6) (log (/ 1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (log (/ 1 re)))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))))) (log (/ 1 re))))))) (log (/ 1 re))))))) (pow re 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ 1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (pow (log (/ 1 re)) 2)))) (pow re 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (* 1/2 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (* 1/2 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (+ (* 1/2 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))) (* 1/2 (/ (- (* -12 (* (pow im 6) (log (/ 1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (pow re 6))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (* 36 (pow (log (/ 1 re)) 2)) (* 16 (pow (log (/ 1 re)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (* 36 (pow (log (/ 1 re)) 2))) (* 16 (pow (log (/ 1 re)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -1 (/ (+ (* -1/3 (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (* 36 (pow (log (/ 1 re)) 2))) (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (* 16 (pow (log (/ 1 re)) 2))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -12 (/ (* (pow im 6) (log (/ 1 re))) (pow re 6))) (* 36 (pow (log (/ 1 re)) 2))) (+ (* -1/3 (/ (* (log (/ 1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* -1/12 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 6))) (+ (* -1/90 (/ (* (log (/ 1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))) (pow re 6))) (+ (* 8 (/ (* (pow im 2) (log (/ 1 re))) (pow re 2))) (+ (* 16 (pow (log (/ 1 re)) 2)) (/ (pow im 4) (pow re 4))))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))) (log 10))) (+ (* 1/2 (/ (- (/ (pow im 6) (log 10)) (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (log 10)))) (pow re 6))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re))))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/2 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re))))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/2 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re))))) (+ (* 1/2 (/ (- (pow im 6) (* 1/720 (+ (* -240 (pow im 6)) (* 720 (pow im 6))))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (* -6 (log (/ -1 re))) (* -4 (log (/ -1 re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (* -4 (log (/ -1 re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 re))) (* -1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))) (+ (* -4 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 re))) (/ (pow im 6) (pow re 6))) (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (* -6 (log (/ -1 re)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (+ (* 1/3 (/ (pow im 18) (pow re 18))) (/ (pow im 6) (pow re 6)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (* -4 (log (/ -1 re)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))) (log 10))) (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ -1 re)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 9/250 (/ (pow im 4) (* (log 10) (log (/ -1 re)))))))) (pow re 4)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow im 2) (log 10))) (+ (* -4/5 (/ (pow im 2) (log 10))) (* -9/25 (/ (pow im 2) (log 10))))) (pow re 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ -1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (log 10))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))))) (* (log 10) (log (/ -1 re))))) (* 6/5 (/ (pow im 6) (log 10)))))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re)))))) (* (log 10) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (log 10) (log (/ -1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (log 10) (log (/ -1 re))))) (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (log 10))))))) (pow re 6))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (log 10) (log (/ -1 re)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (log 10))) (* 9/250 (/ (pow im 4) (* (log 10) (log (/ -1 re)))))))) (pow re 4))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re))))) (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re))))) (+ (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re))))))) (pow re 4)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re))))) (+ (* 1/2 (/ (- (* -4/25 (pow im 2)) (+ (* -4/5 (pow im 2)) (* -9/25 (pow im 2)))) (pow re 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re)))) (+ (* 1/4500 (+ (* -240 (pow im 6)) (* 1440 (pow im 6)))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))))) (log (/ -1 re)))) (* 6/5 (pow im 6))))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re)))))) (log (/ -1 re)))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (log (/ -1 re)))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (log (/ -1 re)))) (* 1/2000 (+ (* -240 (pow im 6)) (* 1440 (pow im 6)))))))) (pow re 6))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re))))))) (pow re 4))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (* -18/5 (log (/ -1 re))) (* -8/5 (log (/ -1 re))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (* -4/25 (/ (pow im 2) (pow re 2)))) (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (* -9/25 (/ (pow im 2) (pow re 2))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ -1 re)))))))) (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ -1 re))))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ -1 re)))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ -1 re))))) (+ (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))))) (* (pow re 6) (log (/ -1 re))))) (* 6/5 (/ (pow im 6) (pow re 6)))))))))) (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re)))))) (* (pow re 6) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ -1 re))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (pow re 6) (log (/ -1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ -1 re)))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -18/5 (log (/ -1 re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -18/5 (log (/ -1 re))) (* 9/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (* -1 (/ (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re))))) (pow re 4)))) (* -9/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 re))) (* 6/5 (/ (pow im 6) (pow re 6)))) (+ (* -9/25 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (* (pow im 2) (+ (* 3/200 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 9/250 (/ (pow im 4) (log (/ -1 re)))))) (* (pow re 6) (log (/ -1 re))))) (+ (* -3/2000 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/2000 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 3/200 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 9/250 (/ (pow im 4) (* (pow re 4) (log (/ -1 re)))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (* 36 (pow (log (/ -1 re)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ -1 re))) (pow re 6))) (* 36 (pow (log (/ -1 re)) 2)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ -1 re))) (pow re 6))) (+ (* 6 (/ (* (pow im 12) (log (/ -1 re))) (pow re 12))) (+ (* 36 (pow (log (/ -1 re)) 2)) (/ (pow im 12) (pow re 12)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow im 6) (log (/ -1 re))) (pow re 6))) (+ (* -4 (/ (* (pow im 18) (log (/ -1 re))) (pow re 18))) (+ (* -1 (/ (pow im 18) (pow re 18))) (+ (* 6 (/ (* (pow im 12) (log (/ -1 re))) (pow re 12))) (+ (* 36 (pow (log (/ -1 re)) 2)) (/ (pow im 12) (pow re 12)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (* -6 (log (/ -1 re)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (+ (* 1/3 (/ (pow im 18) (pow re 18))) (/ (pow im 6) (pow re 6)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (* -10 (log (/ -1 re)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -8/5 (log (/ -1 re)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 re))) (* -4/5 (/ (pow im 2) (pow re 2)))) (* -4/25 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ -1 re))))))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ -1 re))))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 re))) (+ (* -4/5 (/ (pow im 2) (pow re 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (pow re 4) (log (/ -1 re))))) (* -1/10 (/ (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))))) (* (pow re 6) (log (/ -1 re)))))))) (+ (* -4/25 (/ (pow im 2) (pow re 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/4500 (/ (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (pow re 6))) (+ (* 1/150 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (+ (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (* (pow re 4) (log (/ -1 re))))) (* 1/10 (/ (* (pow im 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/150 (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (* 1/10 (/ (* (pow im 2) (- (* -4/5 (pow im 2)) (* -4/25 (pow im 2)))) (log (/ -1 re))))))) (* (pow re 6) (log (/ -1 re)))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (* 16 (pow (log (/ -1 re)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (* 16 (pow (log (/ -1 re)) 2)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* 16 (pow (log (/ -1 re)) 2)) (/ (pow im 4) (pow re 4)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* -1/12 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 6))) (+ (* -1/90 (/ (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))) (pow re 6))) (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* 16 (pow (log (/ -1 re)) 2)) (/ (pow im 4) (pow re 4)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* -4 (log (/ -1 re)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/720 (/ (+ (* -240 (pow im 6)) (* 720 (pow im 6))) (pow re 6))) (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (* (log 10) (log (/ -1 re)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (* (log 10) (log (/ -1 re))))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2))))) (pow re 2))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (* (log 10) (log (/ -1 re))))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))))) (log (/ -1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2))))) (pow re 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (* (log 10) (log (/ -1 re))))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow im 6) (log (/ -1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (* (log 10) (log (/ -1 re))))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))))) (log (/ -1 re)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))))) (log (/ -1 re))))))) (log (/ -1 re))))))) (pow re 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (* (log 10) (log (/ -1 re))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2)))))) (log (/ -1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (/ (pow im 2) (log 10))) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* (log 10) (pow (log (/ -1 re)) 2))))) (pow re 2))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (log (/ -1 re))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (log (/ -1 re)))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2)))) (pow re 2))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (log (/ -1 re)))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2)))) (pow re 2)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))) (log (/ -1 re)))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow im 6) (log (/ -1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (log (/ -1 re)))) (+ (* -1/240 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow im 6)) (* 1440 (pow im 6))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))))) (log (/ -1 re))))))) (log (/ -1 re))))))) (pow re 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (log (/ -1 re)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))) (* 1/10 (/ (* (pow im 2) (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 4))) (* 1/2 (/ (- (* 4/5 (pow im 2)) (* -1/100 (/ (* (pow im 2) (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (pow (log (/ -1 re)) 2)))) (pow re 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (* 1/2 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (* 1/2 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (+ (* 1/2 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))) (* 1/2 (/ (- (* -12 (* (pow im 6) (log (/ -1 re)))) (+ (* -1/12 (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (* -1/90 (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6))))))) (pow re 6))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (* 36 (pow (log (/ -1 re)) 2)) (* 16 (pow (log (/ -1 re)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (* 36 (pow (log (/ -1 re)) 2))) (* 16 (pow (log (/ -1 re)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -1 (/ (+ (* -1/3 (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4))))) (pow im 4)) (pow re 4))) (* 36 (pow (log (/ -1 re)) 2))) (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (* 16 (pow (log (/ -1 re)) 2))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -12 (/ (* (pow im 6) (log (/ -1 re))) (pow re 6))) (* 36 (pow (log (/ -1 re)) 2))) (+ (* -1/3 (/ (* (log (/ -1 re)) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 4))) (+ (* -1/12 (/ (* (pow im 2) (+ (* -12 (pow im 4)) (* 24 (pow im 4)))) (pow re 6))) (+ (* -1/90 (/ (* (log (/ -1 re)) (+ (* -240 (pow im 6)) (* 720 (pow im 6)))) (pow re 6))) (+ (* 8 (/ (* (pow im 2) (log (/ -1 re))) (pow re 2))) (+ (* 16 (pow (log (/ -1 re)) 2)) (/ (pow im 4) (pow re 4))))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (log (pow re 6)) (log (pow re 4))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow re 6)) (log (pow re 4))) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow re 6)) (log (pow re 4))) (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (log (pow re 6)) (log (pow re 4))) (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (log (pow re 6)) (log (pow re 4))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow re 6)) (log (pow re 4)))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow re 6)) (log (pow re 4)))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (log (pow re 6)) (log (pow re 4)))) (* (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 (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (log (pow re 6)) (log (pow re 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow re 6)) (/ (pow im 2) (pow re 2))) (log (pow re 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow re 6)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (log (pow re 4)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (log (pow re 6)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (log (pow re 4)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (log (pow re 6))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow re 6)) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow re 6)) (* (pow im 6) (+ (* -1/2 (/ (pow im 6) (pow re 12))) (/ 1 (pow re 6)))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (log (pow re 6)) (* (pow im 6) (+ (* (pow im 6) (- (* 1/3 (/ (pow im 6) (pow re 18))) (* 1/2 (/ 1 (pow re 12))))) (/ 1 (pow re 6)))))))
#s(approx (pow im 6) #s(hole binary64 (pow im 6)))
#s(approx im #s(hole binary64 im))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (log (pow re 4))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow re 4)) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow re 4)) (* (pow im 2) (- (* 1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (log (pow re 4)) (* (pow im 2) (- (* (pow im 2) (+ (* 2/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow re 4))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1 (pow re 2)) (pow im 2))) (pow re 4))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (+ (* -1 (pow im 2)) (pow re 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (pow im 4) #s(hole binary64 (pow im 4)))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (* (pow im 2) (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))))))) (* 1/2 (/ (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))) (log 10))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))) (log 10))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2)))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 3))))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (/ 1 (* (pow re 4) (* (log 10) (log (pow re 10))))) (/ (log (pow re 4)) (* (pow re 4) (* (log 10) (log (pow re 10))))))))))) (* 1/2 (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))) (log 10))) (* (pow im 2) (+ (* 1/2 (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (* (log 10) (log (pow re 10)))))) (+ (* 5/3 (/ (pow (log (pow re 4)) 2) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (* (log 10) (log (pow re 10)))))) (/ 1 (* (pow re 6) (* (log 10) (log (pow re 10))))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 4))))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (* (log 10) (log (pow re 10)))))) (+ (* 5/3 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 2))))) (/ (pow (log (pow re 6)) 2) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 3)))))))))) (* 1/2 (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2)))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 3))))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2))))) (+ (/ 1 (* (pow re 4) (* (log 10) (log (pow re 10))))) (/ (log (pow re 4)) (* (pow re 4) (* (log 10) (log (pow re 10)))))))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (* (pow im 2) (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))))) (* 1/2 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10)))))))))) (* 1/2 (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))) (* (pow im 2) (+ (* 1/2 (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 4)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (log (pow re 10))))) (/ 1 (* (pow re 6) (log (pow re 10)))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 4)))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 3))))))))) (* 1/2 (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (/ (pow (log (pow re 6)) 2) (log (pow re 10))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow im 2) (- (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10)))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow im 2) (- (+ (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (* (pow im 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10)))))))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10)))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* (pow im 2) (- (+ (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))) (* (pow im 2) (- (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (* (pow im 2) (- (+ (* -1 (/ (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 4)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (log (pow re 10))))) (/ 1 (* (pow re 6) (log (pow re 10)))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 4)))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 3)))))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (+ (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10)))))))))) (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10)))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (/ (pow (log (pow re 6)) 2) (log (pow re 10)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (/ (* (pow im 2) (pow (log (pow re 6)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))) (/ (pow (log (pow re 6)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (* (pow im 2) (- (* (pow im 2) (- (* 2 (/ (log (pow re 6)) (* (pow re 6) (log (pow re 10))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 4)))) (+ (* 5/3 (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (/ (pow (log (pow re 6)) 2) (* (pow re 6) (pow (log (pow re 10)) 3))))))) (+ (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 3)))) (* 1/2 (/ (pow (log (pow re 6)) 2) (* (pow re 4) (pow (log (pow re 10)) 2))))))) (* -1 (/ (pow (log (pow re 6)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 6)) 2) (log (pow re 10))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (pow (log (pow re 6)) 2)))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* 2 (/ (* (pow im 6) (log (pow re 6))) (pow re 6))) (pow (log (pow re 6)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* (pow im 6) (+ (* 2 (/ (log (pow re 6)) (pow re 6))) (* (pow im 6) (+ (* -1 (/ (log (pow re 6)) (pow re 12))) (/ 1 (pow re 12)))))) (pow (log (pow re 6)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* (pow im 6) (+ (* 2 (/ (log (pow re 6)) (pow re 6))) (* (pow im 6) (+ (* -1 (/ (log (pow re 6)) (pow re 12))) (+ (* (pow im 6) (- (* 2/3 (/ (log (pow re 6)) (pow re 18))) (/ 1 (pow re 18)))) (/ 1 (pow re 12))))))) (pow (log (pow re 6)) 2))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (log (pow re 6))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow re 6)) (/ (pow im 6) (pow re 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow re 6)) (* (pow im 6) (+ (* -1/2 (/ (pow im 6) (pow re 12))) (/ 1 (pow re 6)))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (log (pow re 6)) (* (pow im 6) (+ (* (pow im 6) (- (* 1/3 (/ (pow im 6) (pow re 18))) (* 1/2 (/ 1 (pow re 12))))) (/ 1 (pow re 6)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (log (pow re 10))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow re 10)) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow re 10)) (* (pow im 2) (- (* 1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (log (pow re 10)) (* (pow im 2) (- (* (pow im 2) (+ (* 5/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 8))) (pow re 10))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* (pow im 2) (+ (* -1 (pow re 8)) (* (pow im 2) (pow re 6)))) (pow re 10))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* (pow im 2) (+ (* -1 (pow re 8)) (* (pow im 2) (+ (* (pow im 2) (pow re 4)) (pow re 6))))) (pow re 10))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow re 4))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (+ (* (pow im 2) (- (pow im 2) (pow re 2))) (pow re 4))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (+ (* -1 (* (pow im 2) (pow re 2))) (pow re 4))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (/ (pow (log (pow re 4)) 2) (log (pow re 10)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* (pow im 2) (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* (pow im 2) (- (+ (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* (pow im 2) (- (+ (* (pow im 2) (- (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (log (pow re 10))))) (+ (* -1 (/ (- (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (log (pow re 10))))) (+ (* 5/3 (/ (pow (log (pow re 4)) 2) (* (pow re 6) (pow (log (pow re 10)) 2)))) (/ 1 (* (pow re 6) (log (pow re 10))))))))) (+ (/ 1 (* (pow re 4) (log (pow re 10)))) (/ (log (pow re 4)) (* (pow re 4) (log (pow re 10)))))) (+ (* -1 (/ (- (* -2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (pow (log (pow re 4)) 2) (* (pow re 4) (pow (log (pow re 10)) 2)))))))) (* -1 (/ (pow (log (pow re 4)) 2) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (/ (pow (log (pow re 4)) 2) (log (pow re 10))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (pow (log (pow re 4)) 2)))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -2 (/ (* (pow im 2) (log (pow re 4))) (pow re 2))) (pow (log (pow re 4)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* (pow im 2) (+ (* -2 (/ (log (pow re 4)) (pow re 2))) (* (pow im 2) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4)))))) (pow (log (pow re 4)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* (pow im 2) (+ (* -2 (/ (log (pow re 4)) (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 4/3 (/ (log (pow re 4)) (pow re 6))) (/ 1 (pow re 6)))) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))))))) (pow (log (pow re 4)) 2))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (log (pow re 4))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow re 4)) (* -1 (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow re 4)) (* (pow im 2) (- (* 1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (log (pow re 4)) (* (pow im 2) (- (* (pow im 2) (+ (* 2/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (log 10) (log (pow re 10)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (* (pow im 2) (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (log 10) (log (pow re 10))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (log 10) (log (pow re 10))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (* (log 10) (log (pow re 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2))))))))) (* 1/2 (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (log 10) (log (pow re 10))))) (* (pow im 2) (+ (* 1/2 (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2))))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (* (log 10) (log (pow re 10)))))) (/ 1 (* (pow re 6) (* (log 10) (log (pow re 10)))))) (+ (* -1 (/ (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (* (log 10) (log (pow re 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2))))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))) (* (pow re 4) (log (pow re 10))))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (* (log 10) (log (pow re 10)))))) (* 5/3 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 6) (* (log 10) (pow (log (pow re 10)) 2))))))))))) (* 1/2 (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (* (log 10) (log (pow re 10))))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (* (log 10) (log (pow re 10)))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (* (log 10) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (* (log 10) (pow (log (pow re 10)) 2)))))))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (log (pow re 10))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (* (pow im 2) (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (log (pow re 10)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (log (pow re 10)))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (log (pow re 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (pow (log (pow re 10)) 2)))))))) (* 1/2 (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2)))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (log (pow re 10)))) (* (pow im 2) (+ (* 1/2 (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2)))))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (+ (* 2 (/ (log (pow re 6)) (* (pow re 6) (log (pow re 10))))) (/ 1 (* (pow re 6) (log (pow re 10))))) (+ (* -1 (/ (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (log (pow re 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (pow (log (pow re 10)) 2)))))) (* (pow re 2) (log (pow re 10))))) (+ (* 1/2 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 4) (log (pow re 10))))) (+ (* 4/3 (/ (log (pow re 4)) (* (pow re 6) (log (pow re 10))))) (* 5/3 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 6) (pow (log (pow re 10)) 2)))))))))) (* 1/2 (- (* -1 (/ (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))) (log (pow re 10)))) (+ (* -1 (/ (- (* 2 (/ (log (pow re 4)) (* (pow re 2) (log (pow re 10))))) (* -1 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 2) (pow (log (pow re 10)) 2))))) (* (pow re 2) (log (pow re 10))))) (* 1/2 (/ (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)) (* (pow re 4) (pow (log (pow re 10)) 2))))))))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2))) (/ (* (pow im 2) (log (pow re 4))) (pow re 2)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2))) (* (pow im 2) (+ (* -1/2 (* (pow im 2) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))))) (/ (log (pow re 4)) (pow re 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* 1/2 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2))) (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4)))) (* 1/2 (* (pow im 2) (- (+ (* 2 (/ (log (pow re 6)) (pow re 6))) (/ 1 (pow re 6))) (* 4/3 (/ (log (pow re 4)) (pow re 6)))))))) (/ (log (pow re 4)) (pow re 2)))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (pow (log (pow re 6)) 2) (pow (log (pow re 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* 2 (/ (* (pow im 2) (log (pow re 4))) (pow re 2))) (pow (log (pow re 6)) 2)) (pow (log (pow re 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))))) (* -2 (/ (log (pow re 4)) (pow re 2))))) (pow (log (pow re 6)) 2)) (pow (log (pow re 4)) 2))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* (pow im 2) (- (* (pow im 2) (- (* (pow im 2) (- (+ (* 2 (/ (log (pow re 6)) (pow re 6))) (/ 1 (pow re 6))) (* 4/3 (/ (log (pow re 4)) (pow re 6))))) (+ (/ 1 (pow re 4)) (/ (log (pow re 4)) (pow re 4))))) (* -2 (/ (log (pow re 4)) (pow re 2))))) (pow (log (pow re 6)) 2)) (pow (log (pow re 4)) 2))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))) (log 10))) (+ (* 1/2 (/ (- (/ (pow re 6) (log 10)) (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (log 10)))) (pow im 6))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im))))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/2 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im))))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/2 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im))))) (+ (* 1/2 (/ (- (pow re 6) (* 1/720 (+ (* -240 (pow re 6)) (* 720 (pow re 6))))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (* -6 (log (/ 1 im))) (* -4 (log (/ 1 im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (* -4 (log (/ 1 im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 im))) (* -1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))) (+ (* -4 (log (/ 1 im))) (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ 1 im))) (/ (pow re 6) (pow im 6))) (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (* -6 (log (/ 1 im)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (+ (* 1/3 (/ (pow re 18) (pow im 18))) (/ (pow re 6) (pow im 6)))))))
#s(approx (+ (pow im 6) (pow re 6)) #s(hole binary64 (* (pow im 6) (+ 1 (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (* -4 (log (/ 1 im)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (* (pow im 4) (+ 1 (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) #s(hole binary64 (* (pow im 4) (+ 1 (+ (* -1 (/ (pow re 2) (pow im 2))) (/ (pow re 4) (pow im 4)))))))
#s(approx (- (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (- (/ (pow re 2) (pow im 2)) 1))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))) (log 10))) (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ 1 im)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 9/250 (/ (pow re 4) (* (log 10) (log (/ 1 im)))))))) (pow im 4)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ 1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (log 10))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))))) (* (log 10) (log (/ 1 im))))) (* 6/5 (/ (pow re 6) (log 10)))))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im)))))) (* (log 10) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (log 10) (log (/ 1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (log 10) (log (/ 1 im))))) (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (log 10))))))) (pow im 6))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ 1 im)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 9/250 (/ (pow re 4) (* (log 10) (log (/ 1 im)))))))) (pow im 4))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im))))) (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im))))) (+ (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im))))))) (pow im 4)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im))))) (+ (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im)))) (+ (* 1/4500 (+ (* -240 (pow re 6)) (* 1440 (pow re 6)))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))))) (log (/ 1 im)))) (* 6/5 (pow re 6))))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im)))))) (log (/ 1 im)))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (log (/ 1 im)))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (log (/ 1 im)))) (* 1/2000 (+ (* -240 (pow re 6)) (* 1440 (pow re 6)))))))) (pow im 6))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im))))))) (pow im 4))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (* -18/5 (log (/ 1 im))) (* -8/5 (log (/ 1 im))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (* -4/25 (/ (pow re 2) (pow im 2)))) (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (* -9/25 (/ (pow re 2) (pow im 2))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ 1 im)))))))) (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ 1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ 1 im)))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ 1 im))))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))))) (* (pow im 6) (log (/ 1 im))))) (* 6/5 (/ (pow re 6) (pow im 6)))))))))) (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im)))))) (* (pow im 6) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ 1 im))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (pow im 6) (log (/ 1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ 1 im)))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -18/5 (log (/ 1 im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -18/5 (log (/ 1 im))) (* 9/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (* -1 (/ (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im))))) (pow im 4)))) (* -9/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ 1 im))) (* 6/5 (/ (pow re 6) (pow im 6)))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ 1 im)))))) (* (pow im 6) (log (/ 1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ 1 im)))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (* 36 (pow (log (/ 1 im)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ 1 im))) (pow im 6))) (* 36 (pow (log (/ 1 im)) 2)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ 1 im))) (pow im 6))) (+ (* 6 (/ (* (pow re 12) (log (/ 1 im))) (pow im 12))) (+ (* 36 (pow (log (/ 1 im)) 2)) (/ (pow re 12) (pow im 12)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ 1 im))) (pow im 6))) (+ (* -4 (/ (* (pow re 18) (log (/ 1 im))) (pow im 18))) (+ (* -1 (/ (pow re 18) (pow im 18))) (+ (* 6 (/ (* (pow re 12) (log (/ 1 im))) (pow im 12))) (+ (* 36 (pow (log (/ 1 im)) 2)) (/ (pow re 12) (pow im 12)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (* -6 (log (/ 1 im)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (+ (* 1/3 (/ (pow re 18) (pow im 18))) (/ (pow re 6) (pow im 6)))))))
#s(approx (+ (pow re 6) (pow im 6)) #s(hole binary64 (* (pow im 6) (+ 1 (/ (pow re 6) (pow im 6))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (* -10 (log (/ 1 im)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow im 10) (+ 1 (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow im 10) (+ 1 (+ (* -1 (/ (pow re 2) (pow im 2))) (/ (pow re 4) (pow im 4)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* (pow im 10) (+ 1 (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (/ (pow re 4) (pow im 4)) (/ (pow re 6) (pow im 6))))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (* (pow im 4) (+ 1 (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) #s(hole binary64 (* (pow im 4) (- (+ 1 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (- (pow re 4) (pow (* re im) 2)) #s(hole binary64 (* (pow im 2) (- (/ (pow re 4) (pow im 2)) (pow re 2)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -8/5 (log (/ 1 im)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 im))) (* -4/5 (/ (pow re 2) (pow im 2)))) (* -4/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ 1 im))))))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ 1 im))))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ 1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ 1 im))))) (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (pow im 6) (log (/ 1 im)))))))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ 1 im))))) (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ 1 im))))))) (* (pow im 6) (log (/ 1 im)))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (* 16 (pow (log (/ 1 im)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (* 16 (pow (log (/ 1 im)) 2)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* 16 (pow (log (/ 1 im)) 2)) (/ (pow re 4) (pow im 4)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* -1/12 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 6))) (+ (* -1/90 (/ (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))) (pow im 6))) (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* 16 (pow (log (/ 1 im)) 2)) (/ (pow re 4) (pow im 4)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* -4 (log (/ 1 im)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (* (log 10) (log (/ 1 im)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (* (log 10) (log (/ 1 im))))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2))))) (pow im 2))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (* (log 10) (log (/ 1 im))))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))))) (log (/ 1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2))))) (pow im 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (* (log 10) (log (/ 1 im))))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow re 6) (log (/ 1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (* (log 10) (log (/ 1 im))))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))))) (log (/ 1 im)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))))) (log (/ 1 im))))))) (log (/ 1 im))))))) (pow im 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ 1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2)))))) (log (/ 1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* (log 10) (pow (log (/ 1 im)) 2))))) (pow im 2))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (log (/ 1 im))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (log (/ 1 im)))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2)))) (pow im 2))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (log (/ 1 im)))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2)))) (pow im 2)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))) (log (/ 1 im)))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow re 6) (log (/ 1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (log (/ 1 im)))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))))) (log (/ 1 im))))))) (log (/ 1 im))))))) (pow im 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ 1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (pow (log (/ 1 im)) 2)))) (pow im 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (* 1/2 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (* 1/2 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (+ (* 1/2 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))) (* 1/2 (/ (- (* -12 (* (pow re 6) (log (/ 1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (pow im 6))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (* 36 (pow (log (/ 1 im)) 2)) (* 16 (pow (log (/ 1 im)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (* 36 (pow (log (/ 1 im)) 2))) (* 16 (pow (log (/ 1 im)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -1 (/ (+ (* -1/3 (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (* 36 (pow (log (/ 1 im)) 2))) (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (* 16 (pow (log (/ 1 im)) 2))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -12 (/ (* (pow re 6) (log (/ 1 im))) (pow im 6))) (* 36 (pow (log (/ 1 im)) 2))) (+ (* -1/3 (/ (* (log (/ 1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* -1/12 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 6))) (+ (* -1/90 (/ (* (log (/ 1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))) (pow im 6))) (+ (* 8 (/ (* (pow re 2) (log (/ 1 im))) (pow im 2))) (+ (* 16 (pow (log (/ 1 im)) 2)) (/ (pow re 4) (pow im 4))))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))) (log 10)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))) (log 10))) (+ (* 1/2 (/ (- (/ (pow re 6) (log 10)) (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (log 10)))) (pow im 6))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (* 1/2 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* 1/2 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im))))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/2 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im))))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) #s(hole binary64 (+ (* -1/48 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/2 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im))))) (+ (* 1/2 (/ (- (pow re 6) (* 1/720 (+ (* -240 (pow re 6)) (* 720 (pow re 6))))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (* -6 (log (/ -1 im))) (* -4 (log (/ -1 im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (* -4 (log (/ -1 im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 im))) (* -1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))) (+ (* -4 (log (/ -1 im))) (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) #s(hole binary64 (- (+ (* -6 (log (/ -1 im))) (/ (pow re 6) (pow im 6))) (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (* -6 (log (/ -1 im)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (pow im 6) (pow re 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (+ (* 1/3 (/ (pow re 18) (pow im 18))) (/ (pow re 6) (pow im 6)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (* -4 (log (/ -1 im)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (* 1/2 (/ (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))) (log 10)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))) (log 10))) (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ -1 im)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 9/250 (/ (pow re 4) (* (log 10) (log (/ -1 im)))))))) (pow im 4)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))) (log 10))) (+ (* 1/2 (/ (- (* -4/25 (/ (pow re 2) (log 10))) (+ (* -4/5 (/ (pow re 2) (log 10))) (* -9/25 (/ (pow re 2) (log 10))))) (pow im 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ -1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (log 10))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))))) (* (log 10) (log (/ -1 im))))) (* 6/5 (/ (pow re 6) (log 10)))))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im)))))) (* (log 10) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (log 10) (log (/ -1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (log 10) (log (/ -1 im))))) (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (log 10))))))) (pow im 6))) (* 1/2 (/ (- (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (log 10) (log (/ -1 im)))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (log 10))) (* 9/250 (/ (pow re 4) (* (log 10) (log (/ -1 im)))))))) (pow im 4))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (* 1/2 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im))))) (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im))))) (+ (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im))))))) (pow im 4)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) #s(hole binary64 (+ (* 1/2 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im))))) (+ (* 1/2 (/ (- (* -4/25 (pow re 2)) (+ (* -4/5 (pow re 2)) (* -9/25 (pow re 2)))) (pow im 2))) (+ (* 1/2 (/ (- (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im)))) (+ (* 1/4500 (+ (* -240 (pow re 6)) (* 1440 (pow re 6)))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))))) (log (/ -1 im)))) (* 6/5 (pow re 6))))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im)))))) (log (/ -1 im)))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (log (/ -1 im)))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (log (/ -1 im)))) (* 1/2000 (+ (* -240 (pow re 6)) (* 1440 (pow re 6)))))))) (pow im 6))) (* 1/2 (/ (- (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im))))))) (pow im 4))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (* -18/5 (log (/ -1 im))) (* -8/5 (log (/ -1 im))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (* -4/25 (/ (pow re 2) (pow im 2)))) (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (* -9/25 (/ (pow re 2) (pow im 2))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ -1 im)))))))) (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ -1 im))))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ -1 im)))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ -1 im))))) (+ (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))))) (* (pow im 6) (log (/ -1 im))))) (* 6/5 (/ (pow re 6) (pow im 6)))))))))) (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im)))))) (* (pow im 6) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ -1 im))))) (+ (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (pow im 6) (log (/ -1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ -1 im)))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -18/5 (log (/ -1 im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -18/5 (log (/ -1 im))) (* 9/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (* -1 (/ (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im))))) (pow im 4)))) (* -9/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -18/5 (log (/ -1 im))) (* 6/5 (/ (pow re 6) (pow im 6)))) (+ (* -9/25 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (* (pow re 2) (+ (* 3/200 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 9/250 (/ (pow re 4) (log (/ -1 im)))))) (* (pow im 6) (log (/ -1 im))))) (+ (* -3/2000 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/2000 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 3/200 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 9/250 (/ (pow re 4) (* (pow im 4) (log (/ -1 im)))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (* 36 (pow (log (/ -1 im)) 2))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ -1 im))) (pow im 6))) (* 36 (pow (log (/ -1 im)) 2)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ -1 im))) (pow im 6))) (+ (* 6 (/ (* (pow re 12) (log (/ -1 im))) (pow im 12))) (+ (* 36 (pow (log (/ -1 im)) 2)) (/ (pow re 12) (pow im 12)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) #s(hole binary64 (+ (* -12 (/ (* (pow re 6) (log (/ -1 im))) (pow im 6))) (+ (* -4 (/ (* (pow re 18) (log (/ -1 im))) (pow im 18))) (+ (* -1 (/ (pow re 18) (pow im 18))) (+ (* 6 (/ (* (pow re 12) (log (/ -1 im))) (pow im 12))) (+ (* 36 (pow (log (/ -1 im)) 2)) (/ (pow re 12) (pow im 12)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (* -6 (log (/ -1 im)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (/ (pow re 6) (pow im 6)))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))))
#s(approx (log (+ (pow re 6) (pow im 6))) #s(hole binary64 (+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (+ (* 1/3 (/ (pow re 18) (pow im 18))) (/ (pow re 6) (pow im 6)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (* -10 (log (/ -1 im)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) #s(hole binary64 (+ (* -10 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -8/5 (log (/ -1 im)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 im))) (* -4/5 (/ (pow re 2) (pow im 2)))) (* -4/25 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ -1 im))))))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ -1 im))))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (- (+ (* -8/5 (log (/ -1 im))) (+ (* -4/5 (/ (pow re 2) (pow im 2))) (+ (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (pow im 4) (log (/ -1 im))))) (* -1/10 (/ (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))))) (* (pow im 6) (log (/ -1 im)))))))) (+ (* -4/25 (/ (pow re 2) (pow im 2))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/4500 (/ (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (pow im 6))) (+ (* 1/150 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))) (+ (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (* (pow im 4) (log (/ -1 im))))) (* 1/10 (/ (* (pow re 2) (- (* -1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/150 (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (* 1/10 (/ (* (pow re 2) (- (* -4/5 (pow re 2)) (* -4/25 (pow re 2)))) (log (/ -1 im))))))) (* (pow im 6) (log (/ -1 im)))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (* 16 (pow (log (/ -1 im)) 2))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (* 16 (pow (log (/ -1 im)) 2)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* 16 (pow (log (/ -1 im)) 2)) (/ (pow re 4) (pow im 4)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) #s(hole binary64 (+ (* -1/3 (/ (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* -1/12 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 6))) (+ (* -1/90 (/ (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))) (pow im 6))) (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* 16 (pow (log (/ -1 im)) 2)) (/ (pow re 4) (pow im 4)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (* -4 (log (/ -1 im)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (* -1 (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) #s(hole binary64 (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ (pow re 2) (pow im 2))) (+ (* 1/720 (/ (+ (* -240 (pow re 6)) (* 720 (pow re 6))) (pow im 6))) (* 1/24 (/ (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (pow im 4))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (* (log 10) (log (/ -1 im)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (* (log 10) (log (/ -1 im))))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2))))) (pow im 2))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (* (log 10) (log (/ -1 im))))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))))) (log (/ -1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2))))) (pow im 2)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (* (log 10) (log (/ -1 im))))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow re 6) (log (/ -1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (* (log 10) (log (/ -1 im))))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))))) (log (/ -1 im)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))))) (log (/ -1 im))))))) (log (/ -1 im))))))) (pow im 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (* (log 10) (log (/ -1 im))))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2)))))) (log (/ -1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (/ (pow re 2) (log 10))) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* (log 10) (pow (log (/ -1 im)) 2))))) (pow im 2))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (log (/ -1 im))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (log (/ -1 im)))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2)))) (pow im 2))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (log (/ -1 im)))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2)))) (pow im 2)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) #s(hole binary64 (+ (* -1/20 (/ (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))) (log (/ -1 im)))) (+ (* 1/2 (/ (- (* -1/10 (/ (- (* -12 (* (pow re 6) (log (/ -1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (log (/ -1 im)))) (+ (* -1/240 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))) (+ (* 1/72000 (/ (* (+ (* -240 (pow re 6)) (* 1440 (pow re 6))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))))) (log (/ -1 im))))))) (log (/ -1 im))))))) (pow im 6))) (+ (* 1/2 (/ (- (* 1/10 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (log (/ -1 im)))) (+ (* 1/2400 (/ (* (+ (* -12 (pow re 4)) (* 24 (pow re 4))) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))) (* 1/10 (/ (* (pow re 2) (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 4))) (* 1/2 (/ (- (* 4/5 (pow re 2)) (* -1/100 (/ (* (pow re 2) (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (pow (log (/ -1 im)) 2)))) (pow im 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (* 1/2 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (* 1/2 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (* 1/2 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) #s(hole binary64 (+ (* -4 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* -1/2 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (+ (* 1/2 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))) (* 1/2 (/ (- (* -12 (* (pow re 6) (log (/ -1 im)))) (+ (* -1/12 (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (* -1/90 (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6))))))) (pow im 6))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (* 36 (pow (log (/ -1 im)) 2)) (* 16 (pow (log (/ -1 im)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (* 36 (pow (log (/ -1 im)) 2))) (* 16 (pow (log (/ -1 im)) 2)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -1 (/ (+ (* -1/3 (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4))))) (pow re 4)) (pow im 4))) (* 36 (pow (log (/ -1 im)) 2))) (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (* 16 (pow (log (/ -1 im)) 2))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) #s(hole binary64 (- (+ (* -12 (/ (* (pow re 6) (log (/ -1 im))) (pow im 6))) (* 36 (pow (log (/ -1 im)) 2))) (+ (* -1/3 (/ (* (log (/ -1 im)) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 4))) (+ (* -1/12 (/ (* (pow re 2) (+ (* -12 (pow re 4)) (* 24 (pow re 4)))) (pow im 6))) (+ (* -1/90 (/ (* (log (/ -1 im)) (+ (* -240 (pow re 6)) (* 720 (pow re 6)))) (pow im 6))) (+ (* 8 (/ (* (pow re 2) (log (/ -1 im))) (pow im 2))) (+ (* 16 (pow (log (/ -1 im)) 2)) (/ (pow re 4) (pow im 4))))))))))
Outputs
(/.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64))))))) (neg.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64))))))
#s(literal 1/2 binary64)
(-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))))
(log.f64 (/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))))
(log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))
(/.f64 (+.f64 (pow.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 3 binary64)) (pow.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 3 binary64))) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)) (-.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))
(+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))
(pow.f64 im #s(literal 6 binary64))
(exp.f64 (*.f64 (log.f64 im) #s(literal 6 binary64)))
im
#s(literal 6 binary64)
(pow.f64 re #s(literal 6 binary64))
(exp.f64 (*.f64 (log.f64 re) #s(literal 6 binary64)))
re
(log.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64))))
(/.f64 (+.f64 (pow.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im))) (*.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im))) (-.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (*.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im))) (pow.f64 im #s(literal 4 binary64))))))
(fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))
(+.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im))) (pow.f64 im #s(literal 4 binary64)))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 re re)
(pow.f64 re #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(-.f64 (*.f64 re re) (*.f64 im im))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 im im)
(pow.f64 im #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(pow.f64 im #s(literal 4 binary64))
(exp.f64 (*.f64 (log.f64 im) #s(literal 4 binary64)))
#s(literal 4 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))) (neg.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (-.f64 (*.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (*.f64 (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (pow.f64 (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))))) #s(literal 2 binary64)))) (*.f64 (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(-.f64 (/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64))) (neg.f64 (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #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 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
(pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))) #s(literal 2 binary64)))
(log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))
(/.f64 (+.f64 (pow.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 3 binary64)) (pow.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 3 binary64))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)) (-.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (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 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))
#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 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))
(*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal 3 binary64)) (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) #s(literal 3 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)) (-.f64 (*.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 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)))))))
(+.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))))
(-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))
(pow.f64 re #s(literal 4 binary64))
(exp.f64 (*.f64 (log.f64 re) #s(literal 4 binary64)))
(*.f64 (*.f64 re im) (*.f64 re im))
(*.f64 (*.f64 re re) (*.f64 im im))
(pow.f64 (*.f64 re im) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (*.f64 re im)) #s(literal 2 binary64)))
(*.f64 re im)
(/.f64 (neg.f64 (pow.f64 (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))))) #s(literal 2 binary64))) (neg.f64 (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (pow.f64 (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))))) #s(literal 2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(*.f64 (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 (+.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))))))
(pow.f64 (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))))) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (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)))))) #s(literal 2 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)))))
(/.f64 (neg.f64 (/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))) (neg.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64))) (neg.f64 (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64))))))))
(/.f64 (*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (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 re im) #s(literal 2 binary64)))))))
(*.f64 (-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64))) #s(literal 1/2 binary64))
(-.f64 (pow.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 2 binary64)) (pow.f64 (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))))) #s(literal 2 binary64)))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 re re) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))))) (*.f64 #s(literal 1/4 binary64) (pow.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 4 binary64))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (pow.f64 im #s(literal -2 binary64)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (*.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 #s(literal 1/2 binary64) (pow.f64 im #s(literal -2 binary64)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (log.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 im #s(literal 4 binary64)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal 6 binary64) (log.f64 im) (/.f64 (*.f64 re re) (*.f64 im im))) (*.f64 #s(literal 4 binary64) (log.f64 im))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal 6 binary64) (log.f64 im) (*.f64 (*.f64 re re) (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 #s(literal 4 binary64) (log.f64 im))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal 6 binary64) (log.f64 im) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (*.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)))) (pow.f64 im #s(literal -2 binary64))))) (*.f64 #s(literal 4 binary64) (log.f64 im))))
#s(approx (log (+ (pow im 6) (pow re 6))) (*.f64 #s(literal 6 binary64) (log.f64 im)))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal 6 binary64) (log.f64 im) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal 6 binary64) (log.f64 im) (*.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 12 binary64))) (pow.f64 im #s(literal -6 binary64))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal 6 binary64) (log.f64 im) (*.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (-.f64 (*.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 18 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 im #s(literal -12 binary64)))) (pow.f64 im #s(literal -6 binary64))))))
#s(approx (+ (pow im 6) (pow re 6)) (pow.f64 im #s(literal 6 binary64)))
#s(approx (+ (pow im 6) (pow re 6)) (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))
#s(approx (pow re 6) (pow.f64 re #s(literal 6 binary64)))
#s(approx re re)
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (*.f64 #s(literal 4 binary64) (log.f64 im)))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal 4 binary64) (log.f64 im) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal 4 binary64) (log.f64 im) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 im #s(literal -2 binary64))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal 4 binary64) (log.f64 im) (*.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal 2/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))))) (pow.f64 im #s(literal -2 binary64))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (pow.f64 im #s(literal 4 binary64)))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 im re) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -1 binary64) (*.f64 im im) (*.f64 re re)) (pow.f64 im #s(literal 4 binary64))))
#s(approx (* re re) (*.f64 re re))
#s(approx (- (* re re) (* im im)) (*.f64 #s(literal -1 binary64) (*.f64 im im)))
#s(approx (- (* re re) (* im im)) (-.f64 (*.f64 re re) (*.f64 im im)))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (pow.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) #s(literal -1 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 4 binary64))))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64)))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (pow.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal -1 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 4 binary64)))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (pow.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal -1 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 4 binary64)))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64))))))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (+.f64 (/.f64 (pow.f64 (*.f64 re (*.f64 #s(literal 6 binary64) (log.f64 im))) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 4 binary64)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64)))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 3 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 6 binary64) (log.f64 im))) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (pow.f64 im #s(literal 12 binary64))) (pow.f64 im #s(literal -12 binary64))))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (pow.f64 im #s(literal 12 binary64))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (-.f64 (*.f64 #s(literal 2/3 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (pow.f64 im #s(literal 18 binary64)))) (pow.f64 im #s(literal -18 binary64))) (pow.f64 im #s(literal -12 binary64)))))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (log (+ (pow re 6) (pow im 6))) (*.f64 #s(literal 6 binary64) (log.f64 im)))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal 6 binary64) (log.f64 im) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal 6 binary64) (log.f64 im) (*.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 12 binary64))) (pow.f64 im #s(literal -6 binary64))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal 6 binary64) (log.f64 im) (*.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (-.f64 (*.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 18 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 im #s(literal -12 binary64)))) (pow.f64 im #s(literal -6 binary64))))))
#s(approx (+ (pow re 6) (pow im 6)) (pow.f64 im #s(literal 6 binary64)))
#s(approx (+ (pow re 6) (pow im 6)) (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (*.f64 #s(literal 10 binary64) (log.f64 im)))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal 10 binary64) (log.f64 im) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal 10 binary64) (log.f64 im) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 im #s(literal -2 binary64))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal 10 binary64) (log.f64 im) (*.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal 5/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))))) (pow.f64 im #s(literal -2 binary64))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (pow.f64 im #s(literal 10 binary64)))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -1 binary64) (*.f64 (pow.f64 im #s(literal 8 binary64)) (*.f64 re re)) (pow.f64 im #s(literal 10 binary64))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -1 binary64) (pow.f64 im #s(literal 8 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 re re))) (pow.f64 im #s(literal 10 binary64))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -1 binary64) (pow.f64 im #s(literal 8 binary64)) (*.f64 (*.f64 re re) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 re re) (pow.f64 im #s(literal 6 binary64))))) (pow.f64 im #s(literal 10 binary64))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (pow.f64 im #s(literal 4 binary64)))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 im re) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im)) (pow.f64 im #s(literal 4 binary64))))
#s(approx (- (pow re 4) (pow (* re im) 2)) (*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))
#s(approx (- (pow re 4) (pow (* re im) 2)) (*.f64 (*.f64 re re) (-.f64 (*.f64 re re) (*.f64 im im))))
#s(approx (pow re 4) (pow.f64 re #s(literal 4 binary64)))
#s(approx (pow (* re im) 2) (pow.f64 (*.f64 im re) #s(literal 2 binary64)))
#s(approx (* re im) (*.f64 im re))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 (*.f64 re re) (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 (*.f64 re re) (-.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal -1 binary64)))))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 im im)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 im im)) (*.f64 (*.f64 re re) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 im #s(literal -6 binary64))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64)))))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 #s(literal 4 binary64) (log.f64 im)))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal 4 binary64) (log.f64 im) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal 4 binary64) (log.f64 im) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 im #s(literal -2 binary64))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal 4 binary64) (log.f64 im) (*.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal 2/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))))) (pow.f64 im #s(literal -2 binary64))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (pow.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) #s(literal -1 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal 5/3 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64)))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (pow.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal -1 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 5/3 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64)))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 im (*.f64 #s(literal 10 binary64) (log.f64 im))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (*.f64 #s(literal 10 binary64) (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 im)) #s(literal 2 binary64))))))))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (*.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 im im))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 im im))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/2 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 im #s(literal -6 binary64))) (*.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (pow.f64 im #s(literal 6 binary64)))))))) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 im im))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 4 binary64) (log.f64 im))) (*.f64 im im)) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (*.f64 re re) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 im im)))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 im #s(literal -6 binary64))) (*.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im))) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) (*.f64 im im)))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1/720 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re)) (/.f64 (*.f64 im im) (*.f64 re re))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re)) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re)) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 im #s(literal 18 binary64)) (pow.f64 re #s(literal 18 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (+ (pow im 6) (pow re 6)) (pow.f64 re #s(literal 6 binary64)))
#s(approx (+ (pow im 6) (pow re 6)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 #s(literal 1 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (pow.f64 re #s(literal 4 binary64)))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (- (* re re) (* im im)) (*.f64 re re))
#s(approx (- (* re re) (* im im)) (*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (*.f64 re re)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (*.f64 re re)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (*.f64 re re)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (neg.f64 (log.f64 re)))))) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))))))) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 re))))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64)))))))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 im im)) (fma.f64 #s(literal -4/5 binary64) (*.f64 im im) (*.f64 #s(literal -9/25 binary64) (*.f64 im im)))) (*.f64 re re)))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 im im)) (fma.f64 #s(literal -4/5 binary64) (*.f64 im im) (*.f64 #s(literal -9/25 binary64) (*.f64 im im)))) (*.f64 re re)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (neg.f64 (log.f64 re))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 re))))))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 im im)) (fma.f64 #s(literal -4/5 binary64) (*.f64 im im) (*.f64 #s(literal -9/25 binary64) (*.f64 im im)))) (*.f64 re re)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal 1/4500 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (neg.f64 (log.f64 re))))))) (neg.f64 (log.f64 re))) (*.f64 #s(literal 6/5 binary64) (pow.f64 im #s(literal 6 binary64)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 re)))))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal -3/2000 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (neg.f64 (log.f64 re))) (*.f64 #s(literal 1/2000 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64))))))))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (neg.f64 (log.f64 re))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 re))))))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re)))))))) (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (neg.f64 (log.f64 re)))))) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))))))) (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 re))))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal 9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 re))))) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 re))))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 re))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 re))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 6 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 12 binary64)) (neg.f64 (log.f64 re))) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 re))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 18 binary64)) (neg.f64 (log.f64 re))) (pow.f64 re #s(literal 18 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 im #s(literal 18 binary64)) (pow.f64 re #s(literal 18 binary64))) (fma.f64 #s(literal 6 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 12 binary64)) (neg.f64 (log.f64 re))) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re)) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 im #s(literal 18 binary64)) (pow.f64 re #s(literal 18 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (+ (pow re 6) (pow im 6)) (pow.f64 re #s(literal 6 binary64)))
#s(approx (+ (pow re 6) (pow im 6)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 #s(literal 1 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (*.f64 #s(literal -10 binary64) (neg.f64 (log.f64 re))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (pow.f64 re #s(literal 10 binary64)))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 (pow.f64 re #s(literal 10 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 (pow.f64 re #s(literal 10 binary64)) (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 (pow.f64 re #s(literal 10 binary64)) (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (+.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (pow.f64 re #s(literal 4 binary64)))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (- (pow re 4) (pow (* re im) 2)) (pow.f64 re #s(literal 4 binary64)))
#s(approx (- (pow re 4) (pow (* re im) 2)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re))))))) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re)))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 re)))))))) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (neg.f64 (log.f64 re)))))) (neg.f64 (log.f64 re))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (*.f64 re re)) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (*.f64 re re)) (fma.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal -1/12 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/90 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (*.f64 re re)) (fma.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))) (*.f64 re re)))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))))) (neg.f64 (log.f64 re)))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))) (*.f64 re re))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))))))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal 1/72000 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))))) (neg.f64 (log.f64 re))))))) (neg.f64 (log.f64 re))))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))))) (neg.f64 (log.f64 re)))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))) (*.f64 re re)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (log.f64 re)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (log.f64 re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (*.f64 re re)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))) (neg.f64 (log.f64 re)))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (*.f64 re re))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))))))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal 1/72000 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))) (neg.f64 (log.f64 re))))))) (neg.f64 (log.f64 re))))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))) (neg.f64 (log.f64 re)))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (*.f64 re re)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (*.f64 re re)) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (*.f64 re re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (*.f64 re re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))))))) (pow.f64 re #s(literal 6 binary64))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -8 binary64) (/.f64 (*.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (*.f64 re re)) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (*.f64 re re)) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 re))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal -1/12 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/90 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (*.f64 re re)) (fma.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1/720 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (*.f64 im im) (*.f64 re re))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 im #s(literal 18 binary64)) (pow.f64 re #s(literal 18 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (*.f64 re re)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (*.f64 re re)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (*.f64 re re)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))))))) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64)))))))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 im im)) (fma.f64 #s(literal -4/5 binary64) (*.f64 im im) (*.f64 #s(literal -9/25 binary64) (*.f64 im im)))) (*.f64 re re)))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 im im)) (fma.f64 #s(literal -4/5 binary64) (*.f64 im im) (*.f64 #s(literal -9/25 binary64) (*.f64 im im)))) (*.f64 re re)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 im im)) (fma.f64 #s(literal -4/5 binary64) (*.f64 im im) (*.f64 #s(literal -9/25 binary64) (*.f64 im im)))) (*.f64 re re)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal 1/4500 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal 6/5 binary64) (pow.f64 im #s(literal 6 binary64)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal -3/2000 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal 1/2000 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64))))))))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))))) (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))))))) (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal 9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 6 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 12 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 18 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))) (pow.f64 re #s(literal 18 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 im #s(literal 18 binary64)) (pow.f64 re #s(literal 18 binary64))) (fma.f64 #s(literal 6 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 12 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -6 binary64))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 im #s(literal 18 binary64)) (pow.f64 re #s(literal 18 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -10 binary64))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))))) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -4/25 binary64) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 re re)) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 re re)) (fma.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal -1/12 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/90 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 re re)) (fma.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -4 binary64))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))) (*.f64 re re)))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))) (*.f64 re re))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))))))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal 1/72000 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))) (*.f64 re re)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (*.f64 re re)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (*.f64 re re))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 #s(literal 1/72000 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 im #s(literal 6 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 im im)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (*.f64 re re)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 re re)) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 re re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 re re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64)))))))) (pow.f64 re #s(literal 6 binary64))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -8 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 re re)) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 re re)) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal -1/12 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -12 binary64) (pow.f64 im #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/90 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -240 binary64) (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 im #s(literal 6 binary64))))) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 re re)) (fma.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 im im) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))))) (*.f64 #s(literal 1/4 binary64) (pow.f64 (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal -2 binary64)))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64)))) (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal -2 binary64)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (log.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal 6 binary64) (log.f64 re) (/.f64 (*.f64 im im) (*.f64 re re))) (*.f64 #s(literal 4 binary64) (log.f64 re))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal 6 binary64) (log.f64 re) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) (pow.f64 re #s(literal -2 binary64))))) (*.f64 #s(literal 4 binary64) (log.f64 re))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal 6 binary64) (log.f64 re) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/3 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal -4 binary64)))) (pow.f64 re #s(literal -2 binary64))))) (*.f64 #s(literal 4 binary64) (log.f64 re))))
#s(approx (log (+ (pow im 6) (pow re 6))) (*.f64 #s(literal 6 binary64) (log.f64 re)))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal 6 binary64) (log.f64 re) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal 6 binary64) (log.f64 re) (*.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 12 binary64))) (pow.f64 re #s(literal -6 binary64))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal 6 binary64) (log.f64 re) (*.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (-.f64 (*.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 18 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal -12 binary64)))) (pow.f64 re #s(literal -6 binary64))))))
#s(approx (pow im 6) (pow.f64 im #s(literal 6 binary64)))
#s(approx im im)
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (*.f64 #s(literal 4 binary64) (log.f64 re)))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal 4 binary64) (log.f64 re) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal 4 binary64) (log.f64 re) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 re #s(literal -2 binary64))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal 4 binary64) (log.f64 re) (*.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal 2/3 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal -4 binary64))))) (pow.f64 re #s(literal -2 binary64))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 im re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1 binary64) (*.f64 re re) (*.f64 im im)) (pow.f64 re #s(literal 4 binary64))))
#s(approx (- (* re re) (* im im)) (fma.f64 #s(literal -1 binary64) (*.f64 im im) (*.f64 re re)))
#s(approx (* im im) (*.f64 im im))
#s(approx (pow im 4) (pow.f64 im #s(literal 4 binary64)))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (pow.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) #s(literal -1 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 4 binary64))))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64)))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (pow.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal -1 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 4 binary64)))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (pow.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal -1 binary64)))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 4 binary64)))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64))))))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))))))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (+.f64 (/.f64 (pow.f64 (*.f64 im (*.f64 #s(literal 6 binary64) (log.f64 re))) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 4 binary64)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64)))))))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 3 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 #s(literal 6 binary64) (log.f64 re))) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (pow.f64 re #s(literal 6 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (pow.f64 re #s(literal 12 binary64))) (pow.f64 re #s(literal -12 binary64))))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (pow.f64 re #s(literal 6 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (pow.f64 re #s(literal 12 binary64))) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (-.f64 (*.f64 #s(literal 2/3 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (pow.f64 re #s(literal 18 binary64)))) (pow.f64 re #s(literal -18 binary64))) (pow.f64 re #s(literal -12 binary64)))))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (log (+ (pow re 6) (pow im 6))) (*.f64 #s(literal 6 binary64) (log.f64 re)))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal 6 binary64) (log.f64 re) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal 6 binary64) (log.f64 re) (*.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 12 binary64))) (pow.f64 re #s(literal -6 binary64))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal 6 binary64) (log.f64 re) (*.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (-.f64 (*.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 18 binary64)))) (*.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal -12 binary64)))) (pow.f64 re #s(literal -6 binary64))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (*.f64 #s(literal 10 binary64) (log.f64 re)))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal 10 binary64) (log.f64 re) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal 10 binary64) (log.f64 re) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 re #s(literal -2 binary64))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal 10 binary64) (log.f64 re) (*.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal 5/3 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal -4 binary64))))) (pow.f64 re #s(literal -2 binary64))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -1 binary64) (*.f64 (*.f64 im im) (pow.f64 re #s(literal 8 binary64))) (pow.f64 re #s(literal 10 binary64))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1 binary64) (pow.f64 re #s(literal 8 binary64)) (*.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 re #s(literal 10 binary64))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1 binary64) (pow.f64 re #s(literal 8 binary64)) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64)) (pow.f64 re #s(literal 6 binary64))))) (pow.f64 re #s(literal 10 binary64))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 im re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (fma.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)) (pow.f64 re #s(literal 4 binary64))))
#s(approx (- (pow re 4) (pow (* re im) 2)) (fma.f64 #s(literal -1 binary64) (pow.f64 (*.f64 im re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 (*.f64 im im) (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 (*.f64 im im) (-.f64 (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 5/3 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal -1 binary64)))))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))))) (*.f64 #s(literal -1 binary64) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 re re)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 re re)) (*.f64 (*.f64 im im) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 re #s(literal -6 binary64))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64)))))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 #s(literal 4 binary64) (log.f64 re)))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal 4 binary64) (log.f64 re) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal 4 binary64) (log.f64 re) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 re #s(literal -2 binary64))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal 4 binary64) (log.f64 re) (*.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal 2/3 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal -4 binary64))))) (pow.f64 re #s(literal -2 binary64))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (pow.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) #s(literal -1 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal 5/3 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64)))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (pow.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal -1 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 5/3 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64)))))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (fma.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re))))) (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 re (*.f64 #s(literal 10 binary64) (log.f64 re))) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 10 binary64) (log.f64 re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 #s(literal 10 binary64) (log.f64 re)) #s(literal 2 binary64))))))))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (*.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64)))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 re re))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 im im) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 re re))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal 1/2 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (pow.f64 re #s(literal 6 binary64))) (pow.f64 re #s(literal -6 binary64))) (*.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (pow.f64 re #s(literal 6 binary64)))))))) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 re re))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 #s(literal 4 binary64) (log.f64 re))) (*.f64 re re)) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 (*.f64 im im) (-.f64 (*.f64 #s(literal -1 binary64) (*.f64 (*.f64 im im) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 re re)))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (-.f64 (*.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) (pow.f64 re #s(literal 6 binary64))) (pow.f64 re #s(literal -6 binary64))) (*.f64 #s(literal 4/3 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (pow.f64 re #s(literal 6 binary64)))))) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 4 binary64) (log.f64 re))) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -2 binary64) (/.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) (*.f64 re re)))) (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64))) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1/720 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im)) (/.f64 (*.f64 re re) (*.f64 im im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im)) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im)) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))))
#s(approx (+ (pow im 6) (pow re 6)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 #s(literal 1 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (- (* re re) (* im im)) (*.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1 binary64))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (*.f64 im im)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (*.f64 im im)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (*.f64 im im)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (neg.f64 (log.f64 im)))))) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))))))) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64)))))))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 re re)) (fma.f64 #s(literal -4/5 binary64) (*.f64 re re) (*.f64 #s(literal -9/25 binary64) (*.f64 re re)))) (*.f64 im im)))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 re re)) (fma.f64 #s(literal -4/5 binary64) (*.f64 re re) (*.f64 #s(literal -9/25 binary64) (*.f64 re re)))) (*.f64 im im)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (log.f64 im))) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))))))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 re re)) (fma.f64 #s(literal -4/5 binary64) (*.f64 re re) (*.f64 #s(literal -9/25 binary64) (*.f64 re re)))) (*.f64 im im)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (neg.f64 (log.f64 im))) (fma.f64 #s(literal 1/4500 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (neg.f64 (log.f64 im))))))) (neg.f64 (log.f64 im))) (*.f64 #s(literal 6/5 binary64) (pow.f64 re #s(literal 6 binary64)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im)))))) (neg.f64 (log.f64 im))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))))) (neg.f64 (log.f64 im))) (fma.f64 #s(literal -3/2000 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (neg.f64 (log.f64 im))) (*.f64 #s(literal 1/2000 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64))))))))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (log.f64 im))) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))))))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))) (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im)))))))) (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (neg.f64 (log.f64 im)))))) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))))))) (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal 9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))))) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 im))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 im))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 6 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 12 binary64)) (neg.f64 (log.f64 im))) (pow.f64 im #s(literal 12 binary64))) (fma.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 im))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 18 binary64)) (neg.f64 (log.f64 im))) (pow.f64 im #s(literal 18 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (fma.f64 #s(literal 6 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 12 binary64)) (neg.f64 (log.f64 im))) (pow.f64 im #s(literal 12 binary64))) (fma.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im)) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))))
#s(approx (+ (pow re 6) (pow im 6)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 #s(literal 1 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (*.f64 #s(literal -10 binary64) (neg.f64 (log.f64 im))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 (pow.f64 im #s(literal 10 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 (pow.f64 im #s(literal 10 binary64)) (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 (pow.f64 im #s(literal 10 binary64)) (+.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (+.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (- (pow re 4) (pow (* re im) 2)) (*.f64 (*.f64 im im) (-.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 im im)) (*.f64 re re))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im))))))) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im)))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 im)))))))) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (neg.f64 (log.f64 im)))))) (neg.f64 (log.f64 im))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (neg.f64 (log.f64 im))) (*.f64 im im)) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (neg.f64 (log.f64 im))) (*.f64 im im)) (fma.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal -1/12 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal -1/90 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (neg.f64 (log.f64 im))) (*.f64 im im)) (fma.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))) (*.f64 im im)))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))))) (neg.f64 (log.f64 im)))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))) (*.f64 im im))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))))))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))))) (neg.f64 (log.f64 im))) (fma.f64 #s(literal 1/72000 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))))) (neg.f64 (log.f64 im))))))) (neg.f64 (log.f64 im))))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))))) (neg.f64 (log.f64 im)))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))) (*.f64 im im)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (neg.f64 (log.f64 im)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (neg.f64 (log.f64 im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (*.f64 im im)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (neg.f64 (log.f64 im))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))) (neg.f64 (log.f64 im)))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (*.f64 im im))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (neg.f64 (log.f64 im))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))))))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))) (neg.f64 (log.f64 im))) (fma.f64 #s(literal 1/72000 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))) (neg.f64 (log.f64 im))))))) (neg.f64 (log.f64 im))))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))) (neg.f64 (log.f64 im)))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (*.f64 im im)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 re re) (neg.f64 (log.f64 im))) (*.f64 im im)) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 re re) (neg.f64 (log.f64 im))) (*.f64 im im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 re re) (neg.f64 (log.f64 im))) (*.f64 im im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))))))) (pow.f64 im #s(literal 6 binary64))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -8 binary64) (/.f64 (*.f64 (*.f64 re re) (neg.f64 (log.f64 im))) (*.f64 im im)) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (neg.f64 (log.f64 im))) (*.f64 im im)) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (log.f64 im))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal -1/12 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal -1/90 binary64) (/.f64 (*.f64 (neg.f64 (log.f64 im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (neg.f64 (log.f64 im))) (*.f64 im im)) (fma.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))))
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (fma.f64 #s(literal -1/48 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1/720 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 re re) (*.f64 im im))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal -1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))))
#s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)))))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))
#s(approx (log (+ (pow im 6) (pow re 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (*.f64 im im)))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (*.f64 im im)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (/ (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (*.f64 im im)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))))))) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64)))))))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 re re)) (fma.f64 #s(literal -4/5 binary64) (*.f64 re re) (*.f64 #s(literal -9/25 binary64) (*.f64 re re)))) (*.f64 im im)))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 re re)) (fma.f64 #s(literal -4/5 binary64) (*.f64 re re) (*.f64 #s(literal -9/25 binary64) (*.f64 re re)))) (*.f64 im im)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (* 1/2 (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -4/25 binary64) (*.f64 re re)) (fma.f64 #s(literal -4/5 binary64) (*.f64 re re) (*.f64 #s(literal -9/25 binary64) (*.f64 re re)))) (*.f64 im im)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 1/4500 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal 6/5 binary64) (pow.f64 re #s(literal 6 binary64)))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal -3/2000 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal 1/2000 binary64) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64))))))))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))) (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))) (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))))))))
#s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))))))) (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))))))))))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal 9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (pow.f64 im #s(literal 4 binary64))))) (*.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal 6/5 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 #s(literal -9/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal 3/200 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -3/2000 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2000 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 3/200 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 9/250 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 6 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 12 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (pow.f64 im #s(literal 12 binary64))) (fma.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64)))))))
#s(approx (pow (log (+ (pow re 6) (pow im 6))) 2) (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 18 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (pow.f64 im #s(literal 18 binary64))) (fma.f64 #s(literal -1 binary64) (/.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (fma.f64 #s(literal 6 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 12 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (pow.f64 im #s(literal 12 binary64))) (fma.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64)))))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -6 binary64))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))
#s(approx (log (+ (pow re 6) (pow im 6))) (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -10 binary64))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))) (fma.f64 #s(literal -10 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))) (*.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))))
#s(approx (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (-.f64 (fma.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -4/5 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))) (fma.f64 #s(literal -4/25 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/4500 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/150 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/10 binary64) (*.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/150 binary64) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal -4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -4/25 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 im im)) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 im im)) (fma.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal -1/12 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal -1/90 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 im im)) (fma.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)))))))
#s(approx (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) (fma.f64 #s(literal -4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))) (*.f64 im im)))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))) (*.f64 im im))))))
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))))))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 1/72000 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (fma.f64 #s(literal 1/2400 binary64) (*.f64 (/.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal -1/100 binary64) (*.f64 (/.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))) (*.f64 im im)))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (*.f64 im im)))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (*.f64 im im))))))
#s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (fma.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1/10 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -1/240 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 1/72000 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 1440 binary64) (pow.f64 re #s(literal 6 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/10 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2400 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64)))) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 1/10 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 4/5 binary64) (*.f64 re re)) (*.f64 #s(literal -1/100 binary64) (/.f64 (*.f64 (*.f64 re re) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (*.f64 im im)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 im im)) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 im im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))))))
#s(approx (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (fma.f64 #s(literal -4 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 im im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -12 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -1/12 binary64) (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (*.f64 #s(literal -1/90 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64)))))))) (pow.f64 im #s(literal 6 binary64))))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -8 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 im im)) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 #s(literal -1/3 binary64) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 im im)) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))))
#s(approx (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) (-.f64 (fma.f64 #s(literal -12 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (fma.f64 #s(literal -1/3 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal -1/12 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -12 binary64) (pow.f64 re #s(literal 4 binary64)) (*.f64 #s(literal 24 binary64) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal -1/90 binary64) (/.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -240 binary64) (pow.f64 re #s(literal 6 binary64)) (*.f64 #s(literal 720 binary64) (pow.f64 re #s(literal 6 binary64))))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 (*.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 im im)) (fma.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))))))))

eval124.0ms (5.4%)

Memory
22.8MiB live, 303.7MiB allocated; 24ms collecting garbage
Compiler

Compiled 96 763 to 5 990 computations (93.8% saved)

prune30.0ms (1.3%)

Memory
-16.9MiB live, 81.5MiB allocated; 8ms collecting garbage
Pruning

17 alts after pruning (13 fresh and 4 done)

PrunedKeptTotal
New91713930
Fresh000
Picked303
Done044
Total92017937
Accuracy
99.9%
Counts
937 → 17
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓52.2%
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
✓52.3%
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
10.8%
(/.f64 (*.f64 #s(literal 1/2 binary64) #s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (*.f64 #s(literal -18/5 binary64) (neg.f64 (log.f64 re))) (*.f64 #s(literal -8/5 binary64) (neg.f64 (log.f64 re)))))) (log.f64 #s(literal 10 binary64)))
0.0%
(/.f64 (*.f64 #s(literal 1/2 binary64) #s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (log.f64 #s(literal 10 binary64)))
0.0%
(/.f64 (*.f64 #s(literal 1/2 binary64) #s(approx (- (/ (pow (log (+ (pow re 6) (pow im 6))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (/ (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2))))))) (-.f64 (*.f64 #s(literal -18/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (*.f64 #s(literal -8/5 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (log.f64 #s(literal 10 binary64)))
0.0%
(/.f64 (*.f64 #s(literal 1/2 binary64) #s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (fma.f64 #s(literal -6 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 re re) (*.f64 im im))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -4 binary64)))))) (log.f64 #s(literal 10 binary64)))
97.2%
(/.f64 (*.f64 #s(literal 1/2 binary64) #s(approx (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4)))) (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))))) (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)))
10.8%
(/.f64 #s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (log.f64 re))))) (log.f64 #s(literal 10 binary64)))
0.0%
(/.f64 #s(approx (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (log.f64 #s(literal 10 binary64)))
10.8%
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 re)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 re)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 re))))))
96.9%
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 6 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 10 binary64) (log.f64 im))))))
97.6%
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))))
0.0%
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))
0.0%
#s(approx (/ (/ (* (- (pow (log (+ (pow re 6) (pow im 6))) 2) (pow (log (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))) 2)) 1/2) (log (* (+ (pow re 6) (pow im 6)) (+ (pow im 4) (- (pow re 4) (pow (* re im) 2)))))) (log 10)) (*.f64 #s(literal -1/20 binary64) (/.f64 (-.f64 (*.f64 #s(literal 36 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (*.f64 #s(literal 16 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
86.7%
#s(approx (/ (* 1/2 (- (log (+ (pow im 6) (pow re 6))) (log (+ (* (* re re) (- (* re re) (* im im))) (pow im 4))))) (log 10)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (*.f64 #s(literal -6 binary64) (neg.f64 (log.f64 im))) (*.f64 #s(literal -4 binary64) (neg.f64 (log.f64 im)))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
Compiler

Compiled 2 254 to 766 computations (66% saved)

regimes48.0ms (2.1%)

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

8 calls:

7.0ms
re
6.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
6.0ms
im
6.0ms
(*.f64 im im)
5.0ms
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
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)

regimes13.0ms (0.6%)

Memory
-10.8MiB live, 38.9MiB allocated; 2ms collecting garbage
Accuracy

Total -0.2b remaining (-0.8%)

Threshold costs -0.2b (-0.8%)

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

8 calls:

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

Compiled 44 to 38 computations (13.6% saved)

derivations7.0ms (0.3%)

Memory
15.7MiB live, 15.7MiB allocated; 0ms collecting garbage
Stop Event
1×fuel
Compiler

Compiled 19 to 13 computations (31.6% saved)

preprocess25.0ms (1.1%)

Memory
-34.0MiB live, 60.6MiB allocated; 6ms collecting garbage
Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 176 to 148 computations (15.9% saved)

end0.0ms (0%)

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

Profiling

Loading profile data...