math.log10 on complex, real part

Time bar (total: 25.7s)

analyze80.0ms (0.3%)

Memory
-8.3MiB live, 57.0MiB allocated
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)

sample987.0ms (3.8%)

Memory
30.1MiB live, 1 488.8MiB allocated
Samples
730.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 462.0ms
ival-log: 225.0ms (48.7% of total)
ival-hypot: 165.0ms (35.7% of total)
ival-div: 56.0ms (12.1% of total)
ival-true: 7.0ms (1.5% of total)
exact: 5.0ms (1.1% of total)
ival-assert: 3.0ms (0.6% of total)
Bogosity

preprocess24.0ms (0.1%)

Memory
-14.9MiB live, 22.8MiB allocated
Algorithm
1×egg-herbie
Rules
54×sub-neg
34×neg-sub0
30×distribute-lft-neg-in
28×unsub-neg
28×neg-mul-1
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02462
15062
29662
317362
423862
526062
627162
728262
828562
928662
01012
01712
11812
0187
Stop Event
1×iter limit
1×saturated
1×iter limit
1×saturated
Calls
Call 1
Inputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
Outputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
Symmetry

(abs im)

(abs re)

(sort re im)

explain153.0ms (0.6%)

Memory
-3.1MiB live, 234.7MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1390-3(1.2926834818199456e-228 1.5302717827006927e-160)(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-rescue1140
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow114
↳(*.f64 re re)overflow17
↳(*.f64 im im)overflow114
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue220
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow22
↳(*.f64 re re)underflow110
↳(*.f64 im im)underflow22
Confusion
Predicted +Predicted -
+1363
-0117
Precision
1.0
Recall
0.9784172661870504
Confusion?
Predicted +Predicted MaybePredicted -
+13603
-00117
Precision?
1.0
Recall?
0.9784172661870504
Freqs
test
numberfreq
0120
1136
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
52.0ms512×0valid
Compiler

Compiled 126 to 44 computations (65.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 36.0ms
ival-log: 14.0ms (39.3% of total)
ival-hypot: 8.0ms (22.5% of total)
ival-mult: 6.0ms (16.9% of total)
ival-div: 3.0ms (8.4% of total)
ival-add: 2.0ms (5.6% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.4MiB live, 0.4MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

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

Compiled 14 to 10 computations (28.6% saved)

simplify4.0ms (0%)

Memory
6.5MiB live, 6.5MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
✓cost-diff0
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
✓cost-diff0
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓cost-diff128
(+.f64 (*.f64 re re) (*.f64 im im))
Rules
4×lower-hypot.f32
4×lower-hypot.f64
4×lower-fma.f64
4×lift-*.f64
4×lower-fma.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01047
01747
11847
01831
Stop Event
1×iter limit
1×saturated
1×iter limit
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 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(fma.f64 re re (*.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)

localize43.0ms (0.2%)

Memory
-8.1MiB live, 30.0MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.0%
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓accuracy49.8%
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Samples
32.0ms256×0valid
Compiler

Compiled 49 to 12 computations (75.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 24.0ms
ival-mult: 11.0ms (46.3% of total)
ival-log: 6.0ms (25.3% of total)
ival-hypot: 4.0ms (16.8% of total)
ival-div: 2.0ms (8.4% of total)
ival-add: 1.0ms (4.2% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series13.0ms (0.1%)

Memory
19.3MiB live, 19.3MiB allocated
Counts
5 → 96
Calls
Call 1
Inputs
#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())
#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation binary64>) () ())
Outputs
#s(alt (pow im 2) (taylor 0 re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log re) (log 10)) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
Calls

24 calls:

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

rewrite349.0ms (1.4%)

Memory
0.8MiB live, 590.2MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
4 802×lower-fma.f64
4 802×lower-fma.f32
3 340×lower-*.f32
3 336×lower-*.f64
3 206×lower-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01038
01738
14438
225138
3204638
0838722
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
5 → 311
Calls
Call 1
Inputs
(+.f64 (*.f64 re re) (*.f64 im im))
(/.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)))
(log.f64 #s(literal 10 binary64))
Outputs
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))
(exp.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (/.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (/.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 re (+.f64 re im)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 re im)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 re im)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 im im (*.f64 re re)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (fma.f64 im im (*.f64 re re))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 im im (*.f64 re re))))
(/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (-.f64 re im))
(/.f64 (exp.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (exp.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (exp.f64 (log.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (exp.f64 (log.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (exp.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (exp.f64 (log.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))) (exp.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im))))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) #s(literal 1 binary64))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 re im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1 binary64))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (-.f64 re im)) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1 binary64))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 re im)) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (-.f64 re im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 re im) #s(literal 1 binary64))) (*.f64 (-.f64 re im) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (-.f64 re im) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (-.f64 re im) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (-.f64 re im)) (*.f64 (-.f64 re im) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (-.f64 re im) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (neg.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (neg.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (neg.f64 (-.f64 re im)))
(/.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (pow.f64 (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 (*.f64 (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1 binary64))
(*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal -1 binary64)))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 im im (*.f64 re re)))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))))
(*.f64 (pow.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(*.f64 (exp.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (exp.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(*.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (neg.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #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 (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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))
(pow.f64 (exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (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 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 #s(literal 0 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (log.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (log.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)))
(fma.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)))
(neg.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (-.f64 (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64))
(*.f64 #s(literal 1/2 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))) #s(literal 1 binary64)))
(*.f64 #s(literal 2 binary64) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)))
(*.f64 #s(literal 1 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 binary64) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 #s(literal 1/4 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) #s(literal 1/4 binary64)))
(hypot.f64 re im)
(hypot.f64 im re)
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(pow.f64 (exp.f64 #s(literal 1 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.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)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(*.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 re im)))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (pow.f64 (pow.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 (+.f64 re im) (-.f64 re im)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(log.f64 #s(literal 10 binary64))
(exp.f64 (neg.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))

simplify485.0ms (1.9%)

Memory
1.6MiB live, 806.6MiB allocated
Algorithm
1×egg-herbie
Rules
14 804×lower-fma.f64
14 804×lower-fma.f32
4 746×lower-*.f64
4 746×lower-*.f32
3 910×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02681640
17301596
221981594
358171582
084141470
Stop Event
1×iter limit
1×node limit
Counts
96 → 92
Calls
Call 1
Inputs
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
Outputs
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 re (*.f64 re (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 re (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 re (log.f64 #s(literal 10 binary64)))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal 1/2 binary64)) (*.f64 re (*.f64 re (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 re (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 re (log.f64 #s(literal 10 binary64)))))) (-.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 re (*.f64 re (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 re (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 re (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64)))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64)))))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64)))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/4 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 re (*.f64 re (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 re re)) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (log.f64 re)))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal 1/2 binary64)) (*.f64 re re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 re re)) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 im (*.f64 im (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (log.f64 re))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/4 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/4 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (log.f64 im)))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/4 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/4 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 im im) #s(literal 1/2 binary64)) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 (*.f64 im im) #s(literal 1/2 binary64)) (*.f64 re re))) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 re #s(literal 6 binary64))))) re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (*.f64 im im) #s(literal 1/2 binary64)) re) (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 re (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal 1/8 binary64) (fma.f64 (*.f64 im #s(literal -1/2 binary64)) (/.f64 im (*.f64 re re)) #s(literal -1 binary64))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 re (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal 1/8 binary64) #s(literal -1 binary64))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 (*.f64 im im) #s(literal 1/2 binary64)) re)))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 im (*.f64 im (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) re))) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/8 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im)) (fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 im #s(literal 6 binary64))))) im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 im (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64))) (*.f64 #s(literal -1 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))

eval56.0ms (0.2%)

Memory
3.2MiB live, 156.3MiB allocated
Compiler

Compiled 16 389 to 1 712 computations (89.6% saved)

prune71.0ms (0.3%)

Memory
14.6MiB live, 208.3MiB allocated
Pruning

13 alts after pruning (13 fresh and 0 done)

PrunedKeptTotal
New39013403
Fresh000
Picked101
Done000
Total39113404
Accuracy
99.4%
Counts
404 → 13
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶30.5%
(pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
▶30.7%
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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))
45.9%
(/.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (-.f64 (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)))))) (log.f64 #s(literal 10 binary64)))
47.5%
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
14.1%
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
47.6%
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))))
47.6%
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
47.5%
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
▶98.8%
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
47.6%
(/.f64 (log.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 10 binary64)))
▶98.5%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
▶47.6%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
30.3%
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
Compiler

Compiled 676 to 344 computations (49.1% saved)

simplify21.0ms (0.1%)

Memory
2.0MiB live, 38.0MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 19 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
✓cost-diff0
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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))
✓cost-diff704
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
✓cost-diff0
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓cost-diff5824
(pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
✓cost-diff7104
(pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
✓cost-diff704
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓cost-diff0
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
✓cost-diff0
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
✓cost-diff0
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
✓cost-diff0
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
Rules
242×lower-*.f32
234×lower-*.f64
176×lower-/.f32
164×lower-/.f64
146×times-frac
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
026282
047281
169281
2116271
3186271
4308271
5393271
6402271
7408271
8414271
9416271
0416271
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
re
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log.f64 im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(log.f64 #s(literal 10 binary64))
#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))
im
(*.f64 re re)
re
(pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (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 (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))
im
(*.f64 re re)
re
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal 2 binary64)
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(log.f64 #s(literal 10 binary64))
#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))
im
(*.f64 re re)
re
#s(literal -1/2 binary64)
Outputs
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(log.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
re
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log.f64 im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
#s(literal 1/2 binary64)
(log.f64 (fma.f64 im im (*.f64 re re)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
im
(*.f64 re re)
re
(pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
#s(literal 1/2 binary64)
(log.f64 (fma.f64 im im (*.f64 re re)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
im
(*.f64 re re)
re
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal 2 binary64)
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)))) #s(literal -1/2 binary64))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))))
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
#s(literal 1/2 binary64)
(log.f64 (fma.f64 im im (*.f64 re re)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
im
(*.f64 re re)
re
#s(literal -1/2 binary64)

localize150.0ms (0.6%)

Memory
-17.1MiB live, 303.8MiB allocated
Localize:

Found 19 expressions of interest:

NewMetricScoreProgram
✓accuracy99.8%
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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))
✓accuracy99.4%
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
✓accuracy99.3%
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
✓accuracy56.9%
(log.f64 (fma.f64 im im (*.f64 re re)))
✓accuracy99.8%
(pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
✓accuracy99.4%
(pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
✓accuracy99.3%
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓accuracy56.9%
(log.f64 (fma.f64 im im (*.f64 re re)))
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.7%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
✓accuracy99.3%
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
✓accuracy56.9%
(log.f64 (fma.f64 im im (*.f64 re re)))
✓accuracy100.0%
(log.f64 im)
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.3%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓accuracy100.0%
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.8%
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
✓accuracy99.3%
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
Samples
50.0ms189×0valid
19.0ms67×0invalid
Compiler

Compiled 306 to 30 computations (90.2% saved)

Precisions
Click to see histograms. Total time spent on operations: 45.0ms
ival-log: 14.0ms (31.4% of total)
ival-div: 11.0ms (24.7% of total)
ival-mult: 8.0ms (18% of total)
ival-pow: 5.0ms (11.2% of total)
ival-add: 2.0ms (4.5% of total)
ival-sqrt: 2.0ms (4.5% of total)
ival-pow2: 2.0ms (4.5% of total)
exact: 1.0ms (2.2% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

series191.0ms (0.7%)

Memory
28.6MiB live, 301.6MiB allocated
Counts
16 → 336
Calls
Call 1
Inputs
#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())
#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())
#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())
#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())
#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())
#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())
#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())
#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())
Outputs
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/8 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 10)) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 10)) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 10)) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (* 1/2 (pow re 2))) (log 10)))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* -2 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10)))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 2 (/ 1 (* (pow re 4) (log 10)))))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10)))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6))))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6))))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2))))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2))))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt im (taylor -inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow re 2)) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow im 2)) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (log 10) (log (pow re 2)))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ (log 10) (log (pow re 2))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2))))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))))))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ -1 im)))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (log 10) (log (pow im 2)))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ (log 10) (log (pow im 2))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2))))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))))))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 re)))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ -1 re)))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (log (pow re 2))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (log (pow im 2))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #<representation binary64>) () ())) ())
#s(alt (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (taylor 0 im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))) (taylor 0 im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/2 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))) (taylor 0 im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow re 4) (log 10)))) (* 1/3 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))) (taylor 0 im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (taylor inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))) (taylor inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (taylor -inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))) (taylor -inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (taylor 0 re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))) (taylor 0 re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/2 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))) (taylor 0 re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow im 4) (log 10)))) (* 1/3 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))) (taylor 0 re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (taylor inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))) (taylor inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (taylor -inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))) (taylor -inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (taylor 0 im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2))) (taylor 0 im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))) (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2)))))))))) (taylor 0 im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow re 2)))) (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (- (* 1/6 (/ 1 (* (pow re 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (* (pow re 2) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2))))))))))) (taylor 0 im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)) (taylor inf im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))) (taylor inf im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))) (taylor inf im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2))))))) (* (log (/ 1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))))) (taylor inf im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)) (taylor -inf im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))) (taylor -inf im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))) (taylor -inf im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2))))))) (* (log (/ -1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))))) (taylor -inf im) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (taylor 0 re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2))) (taylor 0 re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* -1/2 (* (/ (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))) (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2)))))))))) (taylor 0 re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow im 2)))) (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (* (pow im 2) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2))))))))))) (taylor 0 re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)) (taylor inf re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))) (taylor inf re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))) (taylor inf re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2))))))) (* (log (/ 1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))))) (taylor inf re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)) (taylor -inf re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))) (taylor -inf re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))) (taylor -inf re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2))))))) (* (log (/ -1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))))) (taylor -inf re) (#s(alt (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow re 2)) (log 10))) (taylor 0 im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor 0 im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow im 2)) (log 10))) (taylor 0 re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor 0 re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2))) (taylor 0 im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -8 (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (pow re 2)) 3)))) (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2)))) (taylor 0 im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2))) (* (pow im 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow re 2) (pow (log (pow re 2)) 3)))) (* -4 (* (pow im 2) (+ (* -4 (/ (pow (log 10) 2) (* (pow re 4) (pow (log (pow re 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (pow (log (pow re 2)) 4)))))))) (taylor 0 im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2))) (* (pow im 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow re 2) (pow (log (pow re 2)) 3)))) (* (pow im 2) (+ (* -4 (* (pow im 2) (+ (* -2 (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (* (pow re 2) (pow (log (pow re 2)) 5)))) (+ (* -2 (/ (+ (* -4 (/ (pow (log 10) 2) (* (pow re 4) (pow (log (pow re 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (pow (log (pow re 2)) 4))) (* (pow re 2) (log (pow re 2))))) (/ (* (pow (log 10) 2) (- (* 2/3 (/ (log (pow re 2)) (pow re 6))) (/ 1 (pow re 6)))) (pow (log (pow re 2)) 4)))))) (* -4 (+ (* -4 (/ (pow (log 10) 2) (* (pow re 4) (pow (log (pow re 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (pow (log (pow re 2)) 4))))))))) (taylor 0 im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2)) (taylor inf im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ 1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2))) (taylor inf im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ 1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4))) (pow (log (/ 1 im)) 4)))) (pow im 4))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ 1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2)))) (taylor inf im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ 1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4))) (pow (log (/ 1 im)) 4)))) (pow im 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow re 2) (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4)))) (pow (log (/ 1 im)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow re 6) (log (/ 1 im)))) (* -1 (pow re 6)))) (pow (log (/ 1 im)) 4))) (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ 1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4))) (pow (log (/ 1 im)) 4))))) (log (/ 1 im))))) (pow im 6))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ 1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2)) (taylor -inf im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ -1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2))) (taylor -inf im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ -1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4))) (pow (log (/ -1 im)) 4)))) (pow im 4))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ -1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2)))) (taylor -inf im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ -1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4))) (pow (log (/ -1 im)) 4)))) (pow im 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow re 2) (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4)))) (pow (log (/ -1 im)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow re 6) (log (/ -1 im)))) (* -1 (pow re 6)))) (pow (log (/ -1 im)) 4))) (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ -1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4))) (pow (log (/ -1 im)) 4))))) (log (/ -1 im))))) (pow im 6))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ -1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2))) (taylor 0 re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -8 (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (pow im 2)) 3)))) (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2)))) (taylor 0 re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2))) (* (pow re 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow im 2) (pow (log (pow im 2)) 3)))) (* -4 (* (pow re 2) (+ (* -4 (/ (pow (log 10) 2) (* (pow im 4) (pow (log (pow im 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (pow (log (pow im 2)) 4)))))))) (taylor 0 re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2))) (* (pow re 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow im 2) (pow (log (pow im 2)) 3)))) (* (pow re 2) (+ (* -4 (* (pow re 2) (+ (* -2 (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (* (pow im 2) (pow (log (pow im 2)) 5)))) (+ (* -2 (/ (+ (* -4 (/ (pow (log 10) 2) (* (pow im 4) (pow (log (pow im 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (pow (log (pow im 2)) 4))) (* (pow im 2) (log (pow im 2))))) (/ (* (pow (log 10) 2) (- (* 2/3 (/ (log (pow im 2)) (pow im 6))) (/ 1 (pow im 6)))) (pow (log (pow im 2)) 4)))))) (* -4 (+ (* -4 (/ (pow (log 10) 2) (* (pow im 4) (pow (log (pow im 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (pow (log (pow im 2)) 4))))))))) (taylor 0 re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2)) (taylor inf re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ 1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2))) (taylor inf re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ 1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4))) (pow (log (/ 1 re)) 4)))) (pow re 4))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ 1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2)))) (taylor inf re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ 1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4))) (pow (log (/ 1 re)) 4)))) (pow re 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow im 2) (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4)))) (pow (log (/ 1 re)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow im 6) (log (/ 1 re)))) (* -1 (pow im 6)))) (pow (log (/ 1 re)) 4))) (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ 1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4))) (pow (log (/ 1 re)) 4))))) (log (/ 1 re))))) (pow re 6))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ 1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2)) (taylor -inf re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ -1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2))) (taylor -inf re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ -1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4))) (pow (log (/ -1 re)) 4)))) (pow re 4))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ -1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2)))) (taylor -inf re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ -1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4))) (pow (log (/ -1 re)) 4)))) (pow re 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow im 2) (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4)))) (pow (log (/ -1 re)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow im 6) (log (/ -1 re)))) (* -1 (pow im 6)))) (pow (log (/ -1 re)) 4))) (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ -1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4))) (pow (log (/ -1 re)) 4))))) (log (/ -1 re))))) (pow re 6))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ -1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (patch (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow re 2)) (log 10))) (taylor 0 im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor 0 im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow im 2)) (log 10))) (taylor 0 re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor 0 re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) (patch (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)) #<representation binary64>) () ())) ())
#s(alt (log (pow re 2)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (log (pow im 2)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
Calls

84 calls:

TimeVariablePointExpression
47.0ms
im
@0
(/ (log im) (log 10))
40.0ms
im
@-inf
(/ (log im) (log 10))
17.0ms
im
@-inf
(pow (pow (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) 1/2) 2)
13.0ms
re
@-inf
(pow (pow (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) 1/2) 2)
8.0ms
im
@inf
(/ (log im) (log 10))

rewrite8.0s (31.3%)

Memory
2.0MiB live, 591.8MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 424×lower-fma.f32
5 420×lower-fma.f64
5 344×lower-*.f32
5 336×lower-*.f64
3 064×lower-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
026179
047146
1156146
2941146
08140146
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
16 → 1 131
Calls
Call 1
Inputs
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log.f64 im)
(log.f64 #s(literal 10 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (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 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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)))
Outputs
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))))
(/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(/.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(/.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) #s(literal -1 binary64))
(*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(+.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(+.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (neg.f64 (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(+.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(+.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(-.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(-.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(-.f64 (log.f64 (neg.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))))) (log.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im))) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im)))
(-.f64 (log.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))))) (log.f64 (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64))))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (fma.f64 (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (*.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (fma.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))))
(/.f64 (-.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))))) (*.f64 (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))) (+.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (log.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im))))) (*.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))) (+.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) im)
(+.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(-.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(-.f64 (/.f64 (*.f64 im im) (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64))))) (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))) (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64))))))
(fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 re (/.f64 (*.f64 re (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 re re)) im)
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)
(fma.f64 im #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(fma.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) re im)
(fma.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 #s(literal 1 binary64) im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 (*.f64 re re) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 #s(literal -1 binary64) im) (*.f64 re re)) im)
(fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (/.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 #s(literal -1 binary64) (neg.f64 im) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 re (*.f64 re #s(literal 1/2 binary64))) im)
(fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im)
(fma.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im #s(literal 2 binary64))) (/.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (*.f64 re (*.f64 re re))) (/.f64 (/.f64 #s(literal 1/2 binary64) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (*.f64 re (*.f64 re #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (*.f64 re (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))) (/.f64 re (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (/.f64 re im) (/.f64 re #s(literal 2 binary64)) im)
(fma.f64 (*.f64 (*.f64 re re) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) im) im)
(fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im)
(fma.f64 (/.f64 (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im) im)
(fma.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 (*.f64 (*.f64 re re) (/.f64 #s(literal 1 binary64) im)) #s(literal 1/2 binary64) im)
(fma.f64 (*.f64 (*.f64 re (*.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))) (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (/.f64 (*.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 (/.f64 (*.f64 re re) (neg.f64 im)) #s(literal -1/2 binary64) im)
(neg.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (neg.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(neg.f64 (/.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(neg.f64 (/.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64)))) (-.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))
(/.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))
(/.f64 (neg.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (neg.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(/.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im)) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im))
(/.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))))))
(/.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))))) (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im im))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))))) (neg.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im))) (neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im)))
(/.f64 (neg.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))))) (neg.f64 (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (fma.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))) (fma.f64 (*.f64 re re) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) #s(literal 1 binary64)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))
(/.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im))) #s(literal 1 binary64)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))
(/.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 im (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im im)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))))
(/.f64 (*.f64 (-.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im im)))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal -1 binary64))
(*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (/.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(*.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (/.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(*.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(*.f64 (neg.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(*.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im)) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (neg.f64 (*.f64 re re)) im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im))))
(*.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))))) (/.f64 #s(literal 1 binary64) (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64))))))
(*.f64 (/.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im))) (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64))))) (*.f64 (*.f64 im im) (*.f64 (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64)))) (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64)))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))))) (fma.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64))))) (-.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64))))) (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))))) (*.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))))))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))) (*.f64 im (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64)))))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))) (*.f64 im (+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal -2 binary64)))))))
(*.f64 (/.f64 (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (neg.f64 im))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))))) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) (/.f64 re im))) (*.f64 im (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(neg.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) im) re))
(neg.f64 (*.f64 re (/.f64 #s(literal -1/2 binary64) im)))
(neg.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (neg.f64 im)))
(neg.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(/.f64 re (*.f64 im #s(literal 2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64)))))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 (*.f64 re #s(literal -1/2 binary64)) (neg.f64 im))
(/.f64 (neg.f64 re) (*.f64 im #s(literal -2 binary64)))
(/.f64 (/.f64 re im) #s(literal 2 binary64))
(/.f64 (neg.f64 (*.f64 re #s(literal -1/2 binary64))) im)
(/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) im)
(/.f64 (*.f64 re #s(literal -1 binary64)) (*.f64 im #s(literal -2 binary64)))
(/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal -1 binary64)) (neg.f64 im))
(/.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) #s(literal -1 binary64)) im)
(pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) re)
(*.f64 #s(literal 1 binary64) (/.f64 re (*.f64 im #s(literal 2 binary64))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 #s(literal -1 binary64) im) re))
(*.f64 #s(literal -1/2 binary64) (/.f64 re (neg.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 re #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 re #s(literal 2 binary64)))
(*.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im))
(*.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(*.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im))
(*.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) im))
(*.f64 (/.f64 re #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 (/.f64 re (neg.f64 im)) #s(literal -1/2 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 im)
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im)))
(neg.f64 (neg.f64 (log.f64 im)))
(*.f64 (log.f64 im) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(log.f64 #s(literal 10 binary64))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64))) #s(literal -1/4 binary64)))
(fabs.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(-.f64 (/.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(/.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(/.f64 (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (exp.f64 (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 4 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64)) #s(literal -1/4 binary64))
(pow.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(pow.f64 (exp.f64 #s(literal -1/2 binary64)) (*.f64 #s(literal 2 binary64) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (/.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1 binary64)))
(*.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal -1/2 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (/.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/2 binary64)) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/2 binary64)))
(*.f64 (exp.f64 (log.f64 #s(literal 1/2 binary64))) (exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))))
(*.f64 (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))))
(*.f64 (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))) (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(exp.f64 (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(-.f64 (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(/.f64 #s(literal 2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64))
(/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal -2 binary64) (neg.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1/2 binary64))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(/.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1/2 binary64))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(/.f64 (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) #s(literal 1 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal -2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64)) #s(literal 1/4 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(*.f64 #s(literal 2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 #s(literal 2 binary64) (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 #s(literal -1 binary64) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64))
(*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) #s(literal 2 binary64))
(*.f64 (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal -1 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal -1 binary64)) (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal -1 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64))
(pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(*.f64 #s(literal -1/2 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) #s(literal 1/2 binary64))
(exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64))) #s(literal -1/4 binary64)))
(fabs.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(-.f64 (/.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(/.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(/.f64 (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (exp.f64 (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 4 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64)) #s(literal -1/4 binary64))
(pow.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(pow.f64 (exp.f64 #s(literal -1/2 binary64)) (*.f64 #s(literal 2 binary64) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (/.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1 binary64)))
(*.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal -1/2 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (/.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/2 binary64)) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/2 binary64)))
(*.f64 (exp.f64 (log.f64 #s(literal 1/2 binary64))) (exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))))
(*.f64 (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))))
(*.f64 (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))) (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(fabs.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (neg.f64 (sqrt.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (sqrt.f64 #s(literal -1 binary64))) (neg.f64 (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (neg.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (*.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal -1/4 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64)) #s(literal -1/8 binary64))
(pow.f64 (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1 binary64))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (pow.f64 #s(literal 1 binary64) #s(literal -1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal -1/4 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal -1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (pow.f64 #s(literal -1 binary64) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 1/2 binary64)) (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1/2 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/4 binary64)) (pow.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal -1/4 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/4 binary64)) (pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/4 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/4 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/4 binary64)) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/4 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/4 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/4 binary64)))
(*.f64 (pow.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (sqrt.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(*.f64 (sqrt.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (sqrt.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64))) #s(literal -1/4 binary64)))
(fabs.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(-.f64 (/.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(/.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(/.f64 (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (exp.f64 (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 4 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64)) #s(literal -1/4 binary64))
(pow.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(pow.f64 (exp.f64 #s(literal -1/2 binary64)) (*.f64 #s(literal 2 binary64) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (/.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1 binary64)))
(*.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal -1/2 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (/.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/2 binary64)) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/2 binary64)))
(*.f64 (exp.f64 (log.f64 #s(literal 1/2 binary64))) (exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))))
(*.f64 (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))))
(*.f64 (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))) (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(neg.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(neg.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(neg.f64 (*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(neg.f64 (*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))))
(neg.f64 (/.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(neg.f64 (/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64))))
(neg.f64 (/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) (neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))))))
(/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 #s(literal 2 binary64) (*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))))
(/.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64))) (*.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (neg.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1/2 binary64)))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (fma.f64 re re (*.f64 im im))))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal 1/2 binary64))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 10 binary64))))) (exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))))
(/.f64 (exp.f64 (-.f64 (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 10 binary64)))) (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))) (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)))) (neg.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))))
(/.f64 (neg.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))))) #s(literal -1/2 binary64))
(/.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))
(/.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(/.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(/.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(/.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64))
(/.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal 2 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(/.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(/.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(/.f64 (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))))) #s(literal -1/2 binary64))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))
(/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) #s(literal 1/4 binary64))
(/.f64 (/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64))
(pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal -2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal -1 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(*.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 #s(literal 2 binary64) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(*.f64 #s(literal -1 binary64) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 #s(literal -1 binary64) (*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))))
(*.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64))) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 4 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal 2 binary64))
(*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -2 binary64) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (fma.f64 re re (*.f64 im im)))) (neg.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (log.f64 #s(literal 10 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(*.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64)) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/4 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/4 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(*.f64 (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64))) #s(literal -1/4 binary64)))
(fabs.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(-.f64 (/.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(/.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(/.f64 (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (exp.f64 (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 4 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64)) #s(literal -1/4 binary64))
(pow.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(pow.f64 (exp.f64 #s(literal -1/2 binary64)) (*.f64 #s(literal 2 binary64) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (/.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1 binary64)))
(*.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (/.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))) #s(literal -1/2 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (/.f64 (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)))) #s(literal -1/2 binary64)) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) #s(literal -1/2 binary64)))
(*.f64 (exp.f64 (log.f64 #s(literal 1/2 binary64))) (exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))))
(*.f64 (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))))
(*.f64 (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))) (exp.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -3/4 binary64)) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64))) (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/8 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(log.f64 (fma.f64 re re (*.f64 im im)))
(+.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(+.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(+.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(-.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (log.f64 (neg.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (*.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (*.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (+.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (*.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))))) (+.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))

simplify9.8s (38%)

Memory
-149.8MiB live, 791.5MiB allocated
Algorithm
1×egg-herbie
Rules
11 342×lower-fma.f64
11 342×lower-fma.f32
8 092×lower-*.f64
8 092×lower-*.f32
5 552×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0114110413
1354110012
094259572
Stop Event
1×iter limit
1×node limit
Counts
336 → 333
Calls
Call 1
Inputs
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/8 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 10))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))
(/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 10))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))
(/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 10))
(+ (* -1 (/ (log im) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* -2 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 2 (/ 1 (* (pow re 4) (log 10)))))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* 2 (/ (log 10) (log (pow re 2))))
(+ (* -2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ (log 10) (log (pow re 2)))))
(+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))))))
(+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2)))))))))))
(* -1 (/ (log 10) (log (/ 1 im))))
(+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(* -1 (/ (log 10) (log (/ -1 im))))
(+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(* 2 (/ (log 10) (log (pow im 2))))
(+ (* -2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ (log 10) (log (pow im 2)))))
(+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))))))
(+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2)))))))))))
(* -1 (/ (log 10) (log (/ 1 re))))
(+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(* -1 (/ (log 10) (log (/ -1 re))))
(+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(* 1/2 (log (pow re 2)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* 1/2 (log (pow im 2)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))
(+ (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(+ (* (pow im 2) (+ (* -1/2 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow re 4) (log 10)))) (* 1/3 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))
(+ (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(+ (* (pow re 2) (+ (* -1/2 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow im 4) (log 10)))) (* 1/3 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))) (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))))))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow re 2)))) (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (- (* 1/6 (/ 1 (* (pow re 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (* (pow re 2) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))))))))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2))))))) (* (log (/ 1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))))
(* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2))))))) (* (log (/ -1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))))
(* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* -1/2 (* (/ (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))) (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))))))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow im 2)))) (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (* (pow im 2) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))))))))
(* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2))))))) (* (log (/ 1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))))
(* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2))))))) (* (log (/ -1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2)))
(+ (* -8 (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (pow re 2)) 3)))) (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2))))
(+ (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2))) (* (pow im 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow re 2) (pow (log (pow re 2)) 3)))) (* -4 (* (pow im 2) (+ (* -4 (/ (pow (log 10) 2) (* (pow re 4) (pow (log (pow re 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (pow (log (pow re 2)) 4))))))))
(+ (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2))) (* (pow im 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow re 2) (pow (log (pow re 2)) 3)))) (* (pow im 2) (+ (* -4 (* (pow im 2) (+ (* -2 (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (* (pow re 2) (pow (log (pow re 2)) 5)))) (+ (* -2 (/ (+ (* -4 (/ (pow (log 10) 2) (* (pow re 4) (pow (log (pow re 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (pow (log (pow re 2)) 4))) (* (pow re 2) (log (pow re 2))))) (/ (* (pow (log 10) 2) (- (* 2/3 (/ (log (pow re 2)) (pow re 6))) (/ 1 (pow re 6)))) (pow (log (pow re 2)) 4)))))) (* -4 (+ (* -4 (/ (pow (log 10) 2) (* (pow re 4) (pow (log (pow re 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (pow (log (pow re 2)) 4)))))))))
(/ (pow (log 10) 2) (pow (log (/ 1 im)) 2))
(+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ 1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2)))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ 1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4))) (pow (log (/ 1 im)) 4)))) (pow im 4))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ 1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ 1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4))) (pow (log (/ 1 im)) 4)))) (pow im 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow re 2) (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4)))) (pow (log (/ 1 im)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow re 6) (log (/ 1 im)))) (* -1 (pow re 6)))) (pow (log (/ 1 im)) 4))) (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ 1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4))) (pow (log (/ 1 im)) 4))))) (log (/ 1 im))))) (pow im 6))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ 1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2)))))
(/ (pow (log 10) 2) (pow (log (/ -1 im)) 2))
(+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ -1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2)))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ -1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4))) (pow (log (/ -1 im)) 4)))) (pow im 4))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ -1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ -1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4))) (pow (log (/ -1 im)) 4)))) (pow im 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow re 2) (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4)))) (pow (log (/ -1 im)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow re 6) (log (/ -1 im)))) (* -1 (pow re 6)))) (pow (log (/ -1 im)) 4))) (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ -1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4))) (pow (log (/ -1 im)) 4))))) (log (/ -1 im))))) (pow im 6))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ -1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2)))))
(* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2)))
(+ (* -8 (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (pow im 2)) 3)))) (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2))))
(+ (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2))) (* (pow re 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow im 2) (pow (log (pow im 2)) 3)))) (* -4 (* (pow re 2) (+ (* -4 (/ (pow (log 10) 2) (* (pow im 4) (pow (log (pow im 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (pow (log (pow im 2)) 4))))))))
(+ (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2))) (* (pow re 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow im 2) (pow (log (pow im 2)) 3)))) (* (pow re 2) (+ (* -4 (* (pow re 2) (+ (* -2 (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (* (pow im 2) (pow (log (pow im 2)) 5)))) (+ (* -2 (/ (+ (* -4 (/ (pow (log 10) 2) (* (pow im 4) (pow (log (pow im 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (pow (log (pow im 2)) 4))) (* (pow im 2) (log (pow im 2))))) (/ (* (pow (log 10) 2) (- (* 2/3 (/ (log (pow im 2)) (pow im 6))) (/ 1 (pow im 6)))) (pow (log (pow im 2)) 4)))))) (* -4 (+ (* -4 (/ (pow (log 10) 2) (* (pow im 4) (pow (log (pow im 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (pow (log (pow im 2)) 4)))))))))
(/ (pow (log 10) 2) (pow (log (/ 1 re)) 2))
(+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ 1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2)))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ 1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4))) (pow (log (/ 1 re)) 4)))) (pow re 4))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ 1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ 1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4))) (pow (log (/ 1 re)) 4)))) (pow re 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow im 2) (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4)))) (pow (log (/ 1 re)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow im 6) (log (/ 1 re)))) (* -1 (pow im 6)))) (pow (log (/ 1 re)) 4))) (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ 1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4))) (pow (log (/ 1 re)) 4))))) (log (/ 1 re))))) (pow re 6))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ 1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2)))))
(/ (pow (log 10) 2) (pow (log (/ -1 re)) 2))
(+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ -1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2)))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ -1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4))) (pow (log (/ -1 re)) 4)))) (pow re 4))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ -1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ -1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4))) (pow (log (/ -1 re)) 4)))) (pow re 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow im 2) (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4)))) (pow (log (/ -1 re)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow im 6) (log (/ -1 re)))) (* -1 (pow im 6)))) (pow (log (/ -1 re)) 4))) (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ -1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4))) (pow (log (/ -1 re)) 4))))) (log (/ -1 re))))) (pow re 6))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ -1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2)))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
Outputs
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/8 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/24 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 #s(literal -1/8 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 10))
(/.f64 (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))
(fma.f64 #s(literal -2 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 #s(literal 8/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 10))
(/.f64 (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))
(fma.f64 #s(literal -2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 #s(literal 8/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 10))
(/.f64 (-.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log im) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* -2 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)))) (/.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 2 (/ 1 (* (pow re 4) (log 10)))))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 8/3 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal -2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))))) (/.f64 #s(literal 2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)))) (/.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (/.f64 (*.f64 #s(literal 1/24 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))
(-.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))
(-.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
(-.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/24 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal 8/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (fma.f64 #s(literal -2 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal 8/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(-.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 im))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (-.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 2 binary64) (*.f64 re re))) (-.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 8/3 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -2 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 2 binary64) (*.f64 re re))) (-.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 im)))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 im))) (/.f64 (*.f64 #s(literal 1/24 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 #s(literal 1/24 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 re re) (*.f64 im im)) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 re re) (*.f64 im im)) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 re re) (*.f64 im im)) im)
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64) #s(literal -1 binary64)) (neg.f64 im))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64) #s(literal -1 binary64)) (neg.f64 im))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64) #s(literal -1 binary64)) (neg.f64 im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (*.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* 2 (/ (log 10) (log (pow re 2))))
(/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 re re)))
(+ (* -2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ (log 10) (log (pow re 2)))))
(fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))) (/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 re re))))
(+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))))))
(fma.f64 #s(literal 2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))) (*.f64 (*.f64 (*.f64 im im) #s(literal -2 binary64)) (fma.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))))))
(+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2)))))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 (*.f64 im im) #s(literal -2 binary64)) (fma.f64 (*.f64 im im) (-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/3 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))))) (/.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64))))) (*.f64 (*.f64 re re) (log.f64 (*.f64 re re))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))))) (/.f64 (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))))) (/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 re re))))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)) (*.f64 (*.f64 im im) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))
(fma.f64 #s(literal -2 binary64) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)) (*.f64 (*.f64 im im) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))))) (log.f64 im)) (fma.f64 #s(literal 1/12 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)) (*.f64 (*.f64 im im) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (/ (log 10) (log (/ -1 im))))
(neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(-.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (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))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))
(fma.f64 #s(literal -2 binary64) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (pow.f64 im #s(literal 4 binary64))) (-.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (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)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 1/12 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))))) (pow.f64 im #s(literal 6 binary64)))) (-.f64 (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (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)))))
(* 2 (/ (log 10) (log (pow im 2))))
(/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 im im)))
(+ (* -2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ (log 10) (log (pow im 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))) (/.f64 (*.f64 (*.f64 #s(literal -2 binary64) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))))
(+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))))))
(fma.f64 (*.f64 (*.f64 re re) #s(literal -2 binary64)) (fma.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64))))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))))) (/.f64 (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 im im))))
(+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2)))))))))))
(fma.f64 #s(literal 2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))) (*.f64 (*.f64 re re) (fma.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))) (*.f64 (*.f64 (*.f64 re re) #s(literal -2 binary64)) (fma.f64 (*.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/3 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))))) (/.f64 (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64))))) (*.f64 (*.f64 im im) (log.f64 (*.f64 im im))))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64))))))))))
(* -1 (/ (log 10) (log (/ 1 re))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))
(+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im) (*.f64 (*.f64 re re) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))
(fma.f64 #s(literal -2 binary64) (/.f64 (fma.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im) (*.f64 (*.f64 re re) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (fma.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (fma.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal 1/12 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im) (*.f64 (*.f64 re re) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(* -1 (/ (log 10) (log (/ -1 re))))
(neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (*.f64 (*.f64 re re) (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))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))
(fma.f64 #s(literal -2 binary64) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (pow.f64 re #s(literal 4 binary64))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (*.f64 (*.f64 re re) (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)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (fma.f64 #s(literal 1/12 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (/.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))))) (pow.f64 re #s(literal 6 binary64)))) (-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (*.f64 (*.f64 re re) (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)))))
(* 1/2 (log (pow re 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* 1/2 (log (pow im 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))
(+ (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* (pow im 2) (+ (* -1/2 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (*.f64 im im) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow re 4) (log 10)))) (* 1/3 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (*.f64 im im) (*.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))))
(* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(-.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
(+ (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* (pow re 2) (+ (* -1/2 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow im 4) (log 10)))) (* 1/3 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))))
(* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
(* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)))
(fma.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) re) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re)))))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))) (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/16 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (*.f64 re re))))))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))))) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) re) re)))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow re 2)))) (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (- (* 1/6 (/ 1 (* (pow re 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (* (pow re 2) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re)))) (*.f64 im im)) (/.f64 (+.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/16 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (*.f64 re re)))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (log.f64 (*.f64 re re)))))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))))) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/16 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (*.f64 re re)))))) (sqrt.f64 #s(literal 1/2 binary64))))) (*.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) re) re)))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal -1 binary64)))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))
(fma.f64 (sqrt.f64 (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal -1 binary64)) (*.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))))
(fma.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal -1 binary64)))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2))))))) (* (log (/ 1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))))
(fma.f64 (sqrt.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))) (log.f64 im)))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (sqrt.f64 #s(literal -1 binary64)))))) (fma.f64 (sqrt.f64 (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal -1 binary64)) (*.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))))))
(* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))
(fma.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2))))))) (* (log (/ -1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (sqrt.f64 #s(literal -1 binary64)))))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))))
(* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)))
(fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (sqrt.f64 #s(literal 1/2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* -1/2 (* (/ (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))) (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))))) (/.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/16 binary64) (*.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im)))) #s(literal 1/2 binary64))))) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))))) (*.f64 (*.f64 im im) (sqrt.f64 #s(literal 1/2 binary64)))))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow im 2)))) (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (* (pow im 2) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im)))) (*.f64 re re)) (/.f64 (+.f64 (/.f64 #s(literal 1/6 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (*.f64 #s(literal 1/4 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/16 binary64) (*.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im)))) #s(literal 1/2 binary64)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (log.f64 (*.f64 im im)))))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))))) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/16 binary64) (*.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im)))) #s(literal 1/2 binary64)))) (sqrt.f64 #s(literal 1/2 binary64))))) (*.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))))) (*.f64 (*.f64 im im) (sqrt.f64 #s(literal 1/2 binary64)))))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))
(fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) re) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))) (sqrt.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) re) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2))))))) (* (log (/ 1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))))
(fma.f64 (sqrt.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))) (log.f64 re)))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (sqrt.f64 #s(literal -1 binary64)))))) (fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) re) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))))))
(* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) re) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))))
(fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) re) re)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2))))))) (* (log (/ -1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))))) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (sqrt.f64 #s(literal -1 binary64)))))) (fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))) (*.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) re) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (*.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2)))
(/.f64 (*.f64 #s(literal 4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))
(+ (* -8 (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (pow re 2)) 3)))) (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2))))
(fma.f64 #s(literal 4 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -8 binary64) (*.f64 im im)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))))
(+ (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2))) (* (pow im 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow re 2) (pow (log (pow re 2)) 3)))) (* -4 (* (pow im 2) (+ (* -4 (/ (pow (log 10) 2) (* (pow re 4) (pow (log (pow re 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (pow (log (pow re 2)) 4))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 16 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 4 binary64)))) (*.f64 (*.f64 #s(literal -4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (*.f64 re re)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 4 binary64))))) (/.f64 (*.f64 #s(literal -8 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64))))) (/.f64 (*.f64 #s(literal 4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))))
(+ (* 4 (/ (pow (log 10) 2) (pow (log (pow re 2)) 2))) (* (pow im 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow re 2) (pow (log (pow re 2)) 3)))) (* (pow im 2) (+ (* -4 (* (pow im 2) (+ (* -2 (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (* (pow re 2) (pow (log (pow re 2)) 5)))) (+ (* -2 (/ (+ (* -4 (/ (pow (log 10) 2) (* (pow re 4) (pow (log (pow re 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (pow (log (pow re 2)) 4))) (* (pow re 2) (log (pow re 2))))) (/ (* (pow (log 10) 2) (- (* 2/3 (/ (log (pow re 2)) (pow re 6))) (/ 1 (pow re 6)))) (pow (log (pow re 2)) 4)))))) (* -4 (+ (* -4 (/ (pow (log 10) 2) (* (pow re 4) (pow (log (pow re 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow re 2)) (pow re 4))) (/ 1 (pow re 4)))) (pow (log (pow re 2)) 4)))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (*.f64 #s(literal -4 binary64) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -2 binary64) (fma.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (*.f64 re re)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 5 binary64)))) (/.f64 (fma.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (*.f64 re re)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 4 binary64))))) (*.f64 (*.f64 re re) (log.f64 (*.f64 re re))))) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 #s(literal 2/3 binary64) (/.f64 (log.f64 (*.f64 re re)) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 re #s(literal 6 binary64))))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 4 binary64)))) (fma.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (*.f64 re re)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 4 binary64))))))) (/.f64 (*.f64 #s(literal -8 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64))))) (/.f64 (*.f64 #s(literal 4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))))
(/ (pow (log 10) 2) (pow (log (/ 1 im)) 2))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))
(+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ 1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2)))
(fma.f64 (*.f64 re re) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ 1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4))) (pow (log (/ 1 im)) 4)))) (pow im 4))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ 1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2))))
(fma.f64 #s(literal -4 binary64) (/.f64 (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 #s(literal 2 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (*.f64 re re) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ 1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4))) (pow (log (/ 1 im)) 4)))) (pow im 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow re 2) (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4)))) (pow (log (/ 1 im)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow re 6) (log (/ 1 im)))) (* -1 (pow re 6)))) (pow (log (/ 1 im)) 4))) (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ 1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ 1 im)))) (pow re 4))) (pow (log (/ 1 im)) 4))))) (log (/ 1 im))))) (pow im 6))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ 1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 im)) 2)))))
(fma.f64 #s(literal -4 binary64) (+.f64 (/.f64 (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 #s(literal 2 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (fma.f64 #s(literal 1/16 binary64) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 #s(literal 2 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 5 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 (*.f64 #s(literal -4/3 binary64) (pow.f64 re #s(literal 6 binary64))) (neg.f64 (log.f64 im)) (neg.f64 (pow.f64 re #s(literal 6 binary64))))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 4 binary64)))) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 #s(literal 2 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (log.f64 im))) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 4 binary64))))) (neg.f64 (log.f64 im)))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (*.f64 re re) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))
(/ (pow (log 10) 2) (pow (log (/ -1 im)) 2))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))
(+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ -1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2)))
(fma.f64 (*.f64 re re) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ -1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4))) (pow (log (/ -1 im)) 4)))) (pow im 4))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ -1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2))))
(fma.f64 #s(literal -4 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (*.f64 re re) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ -1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4))) (pow (log (/ -1 im)) 4)))) (pow im 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow re 2) (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4)))) (pow (log (/ -1 im)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow re 6) (log (/ -1 im)))) (* -1 (pow re 6)))) (pow (log (/ -1 im)) 4))) (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (pow (log 10) 2)) (pow (log (/ -1 im)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow re 4) (log (/ -1 im)))) (pow re 4))) (pow (log (/ -1 im)) 4))))) (log (/ -1 im))))) (pow im 6))) (+ (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (/ -1 im)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 im)) 2)))))
(fma.f64 #s(literal -4 binary64) (+.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (fma.f64 #s(literal 1/16 binary64) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 5 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 #s(literal -4/3 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (pow.f64 re #s(literal 6 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 4 binary64)))) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (*.f64 re re) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))
(* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2)))
(/.f64 (*.f64 #s(literal 4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))
(+ (* -8 (/ (* (pow re 2) (pow (log 10) 2)) (* (pow im 2) (pow (log (pow im 2)) 3)))) (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2))))
(fma.f64 #s(literal 4 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -8 binary64) (*.f64 re re)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))))
(+ (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2))) (* (pow re 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow im 2) (pow (log (pow im 2)) 3)))) (* -4 (* (pow re 2) (+ (* -4 (/ (pow (log 10) 2) (* (pow im 4) (pow (log (pow im 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (pow (log (pow im 2)) 4))))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal 16 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 4 binary64)))) (*.f64 (*.f64 #s(literal -4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 4 binary64))))) (/.f64 (*.f64 #s(literal -8 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64))))) (/.f64 (*.f64 #s(literal 4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))))
(+ (* 4 (/ (pow (log 10) 2) (pow (log (pow im 2)) 2))) (* (pow re 2) (+ (* -8 (/ (pow (log 10) 2) (* (pow im 2) (pow (log (pow im 2)) 3)))) (* (pow re 2) (+ (* -4 (* (pow re 2) (+ (* -2 (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (* (pow im 2) (pow (log (pow im 2)) 5)))) (+ (* -2 (/ (+ (* -4 (/ (pow (log 10) 2) (* (pow im 4) (pow (log (pow im 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (pow (log (pow im 2)) 4))) (* (pow im 2) (log (pow im 2))))) (/ (* (pow (log 10) 2) (- (* 2/3 (/ (log (pow im 2)) (pow im 6))) (/ 1 (pow im 6)))) (pow (log (pow im 2)) 4)))))) (* -4 (+ (* -4 (/ (pow (log 10) 2) (* (pow im 4) (pow (log (pow im 2)) 4)))) (/ (* (pow (log 10) 2) (+ (* -1 (/ (log (pow im 2)) (pow im 4))) (/ 1 (pow im 4)))) (pow (log (pow im 2)) 4)))))))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -8 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))) (*.f64 (*.f64 (*.f64 re re) #s(literal -4 binary64)) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -2 binary64) (fma.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 5 binary64)))) (/.f64 (fma.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 4 binary64))))) (*.f64 (*.f64 im im) (log.f64 (*.f64 im im))))) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 #s(literal 2/3 binary64) (/.f64 (log.f64 (*.f64 im im)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 im #s(literal 6 binary64))))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 4 binary64)))) (fma.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (*.f64 im im)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal -4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 4 binary64)))))))) (/.f64 (*.f64 #s(literal 4 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))))
(/ (pow (log 10) 2) (pow (log (/ 1 re)) 2))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))
(+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ 1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2)))
(fma.f64 (*.f64 im im) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ 1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4))) (pow (log (/ 1 re)) 4)))) (pow re 4))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ 1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2))))
(fma.f64 #s(literal -4 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (*.f64 im im) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ 1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4))) (pow (log (/ 1 re)) 4)))) (pow re 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow im 2) (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4)))) (pow (log (/ 1 re)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow im 6) (log (/ 1 re)))) (* -1 (pow im 6)))) (pow (log (/ 1 re)) 4))) (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ 1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ 1 re)))) (pow im 4))) (pow (log (/ 1 re)) 4))))) (log (/ 1 re))))) (pow re 6))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ 1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ 1 re)) 2)))))
(fma.f64 #s(literal -4 binary64) (+.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (fma.f64 #s(literal 1/16 binary64) (fma.f64 (*.f64 im im) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 5 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 #s(literal -4/3 binary64) (pow.f64 im #s(literal 6 binary64))) (neg.f64 (log.f64 re))) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 4 binary64)))) (neg.f64 (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (log.f64 re)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 4 binary64))))) (log.f64 re)))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (*.f64 im im) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))
(/ (pow (log 10) 2) (pow (log (/ -1 re)) 2))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))
(+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ -1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2)))
(fma.f64 (*.f64 im im) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ -1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4))) (pow (log (/ -1 re)) 4)))) (pow re 4))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ -1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2))))
(fma.f64 #s(literal -4 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (*.f64 im im) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))
(+ (* -4 (/ (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ -1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4))) (pow (log (/ -1 re)) 4)))) (pow re 4))) (+ (* -4 (/ (+ (* 1/16 (/ (* (pow im 2) (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4)))) (pow (log (/ -1 re)) 5))) (+ (* 1/16 (/ (* (pow (log 10) 2) (+ (* -4/3 (* (pow im 6) (log (/ -1 re)))) (* -1 (pow im 6)))) (pow (log (/ -1 re)) 4))) (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (pow (log 10) 2)) (pow (log (/ -1 re)) 4))) (* 1/16 (/ (* (pow (log 10) 2) (+ (* 2 (* (pow im 4) (log (/ -1 re)))) (pow im 4))) (pow (log (/ -1 re)) 4))))) (log (/ -1 re))))) (pow re 6))) (+ (/ (* (pow im 2) (pow (log 10) 2)) (* (pow re 2) (pow (log (/ -1 re)) 3))) (/ (pow (log 10) 2) (pow (log (/ -1 re)) 2)))))
(fma.f64 #s(literal -4 binary64) (+.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 4 binary64)))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (fma.f64 #s(literal 1/16 binary64) (fma.f64 (*.f64 im im) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 5 binary64))) (/.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 #s(literal -4/3 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (pow.f64 im #s(literal 6 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 4 binary64)))) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (*.f64 im im) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (*.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 #s(literal -1/4 binary64) (*.f64 re re)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(* -2 (log (/ 1 im)))
(*.f64 #s(literal 2 binary64) (log.f64 im))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (/.f64 (*.f64 re re) (*.f64 im im)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
(* -2 (log (/ -1 im)))
(*.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 re re) (*.f64 im im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(* -2 (log (/ 1 re)))
(neg.f64 (*.f64 (log.f64 re) #s(literal -2 binary64)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
(* -2 (log (/ -1 re)))
(*.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))

eval342.0ms (1.3%)

Memory
8.0MiB live, 506.2MiB allocated
Compiler

Compiled 56 502 to 4 611 computations (91.8% saved)

prune260.0ms (1%)

Memory
7.7MiB live, 654.4MiB allocated
Pruning

20 alts after pruning (18 fresh and 2 done)

PrunedKeptTotal
New1 978151 993
Fresh538
Picked325
Done000
Total1 986202 006
Accuracy
100.0%
Counts
2 006 → 20
Alt Table
Click to see full alt table
StatusAccuracyProgram
72.9%
(pow.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
73.3%
(pow.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) #s(literal -1/2 binary64))
30.4%
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
98.1%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
▶47.5%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
▶14.1%
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
47.6%
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))))
47.5%
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
▶47.6%
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
▶98.4%
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
▶98.8%
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓98.8%
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
✓98.5%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
98.4%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
47.5%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
98.4%
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
98.0%
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
47.4%
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
30.7%
(sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
72.5%
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
Compiler

Compiled 617 to 430 computations (30.3% saved)

simplify292.0ms (1.1%)

Memory
-9.7MiB live, 536.0MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))
✓cost-diff0
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
✓cost-diff320
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
✓cost-diff0
(/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
✓cost-diff0
(log.f64 #s(literal 1/10 binary64))
✓cost-diff0
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓cost-diff1088
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
✓cost-diff0
(fma.f64 im im (*.f64 re re))
✓cost-diff0
(log.f64 (fma.f64 im im (*.f64 re re)))
✓cost-diff0
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64))
✓cost-diff0
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓cost-diff0
(log.f64 #s(literal 1/10 binary64))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(neg.f64 (log.f64 im))
✓cost-diff0
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓cost-diff0
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
✓cost-diff0
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
✓cost-diff0
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
✓cost-diff0
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
Rules
13 362×lower-fma.f32
13 352×lower-fma.f64
2 478×lower-*.f32
2 452×lower-*.f64
1 728×unsub-neg
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
046453
087397
1155349
2274335
3570335
41335335
52737335
64338335
76664335
08052330
Stop Event
1×iter limit
1×node limit
1×iter limit
Calls
Call 1
Inputs
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
re
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 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))
im
(*.f64 re re)
re
#s(literal 1/2 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal 1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
#s(literal -2 binary64)
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))
#s(literal 1/2 binary64)
(log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))
(fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))
re
(*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))
(*.f64 re (*.f64 re (*.f64 re re)))
(*.f64 re (*.f64 re re))
(*.f64 re re)
(*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))
(*.f64 im (*.f64 im im))
im
(*.f64 im im)
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))
(*.f64 (+.f64 re im) (-.f64 im re))
(+.f64 re im)
(-.f64 im re)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
Outputs
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(log.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
re
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 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 re re (*.f64 im im))))
(log.f64 (fma.f64 im im (*.f64 re re)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
im
(*.f64 re re)
re
#s(literal 1/2 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal 1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
#s(literal -2 binary64)
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im (+.f64 re im)) (*.f64 im (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im (+.f64 re im)) (*.f64 im (-.f64 im re)))))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))))
#s(literal 1/2 binary64)
(log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))
(log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))
(fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))
(fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))
re
(*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))
(*.f64 re (*.f64 re (*.f64 re re)))
(*.f64 re (*.f64 re re))
(*.f64 re re)
(*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))
(*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))
(*.f64 im (*.f64 im im))
im
(*.f64 im im)
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im (+.f64 re im)) (*.f64 im (-.f64 im re))))))
(log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im (+.f64 re im)) (*.f64 im (-.f64 im re)))))
(fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))
(fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im (+.f64 re im)) (*.f64 im (-.f64 im re))))
(*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))
(*.f64 (*.f64 im (+.f64 re im)) (*.f64 im (-.f64 im re)))
(*.f64 (+.f64 re im) (-.f64 im re))
(+.f64 re im)
(-.f64 im re)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)

localize193.0ms (0.7%)

Memory
23.8MiB live, 296.9MiB allocated
Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
✓accuracy99.0%
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
✓accuracy98.7%
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
✓accuracy25.1%
(log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
✓accuracy16.8%
(log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))
✓accuracy99.5%
(/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
✓accuracy98.4%
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓accuracy98.4%
(log.f64 #s(literal 1/10 binary64))
✓accuracy48.0%
(log.f64 (fma.f64 re re (*.f64 im im)))
✓accuracy100.0%
(*.f64 re re)
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.0%
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓accuracy48.0%
(log.f64 (fma.f64 im im (*.f64 re re)))
✓accuracy100.0%
(neg.f64 (log.f64 im))
✓accuracy100.0%
(log.f64 im)
✓accuracy99.0%
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓accuracy98.4%
(log.f64 #s(literal 1/10 binary64))
✓accuracy100.0%
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
✓accuracy99.7%
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
✓accuracy99.0%
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓accuracy98.4%
(log.f64 #s(literal 1/10 binary64))
Samples
100.0ms256×0valid
Compiler

Compiled 476 to 50 computations (89.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 74.0ms
ival-mult: 23.0ms (31% of total)
ival-log: 23.0ms (31% of total)
ival-div: 13.0ms (17.5% of total)
ival-add: 7.0ms (9.4% of total)
const: 4.0ms (5.4% of total)
ival-sub: 2.0ms (2.7% of total)
ival-neg: 2.0ms (2.7% of total)
exact: 1.0ms (1.3% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

series153.0ms (0.6%)

Memory
-38.6MiB live, 185.7MiB allocated
Counts
23 → 432
Calls
Call 1
Inputs
#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())
#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())
#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())
#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())
#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())
#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 1/10 binary64)) (patch (log.f64 #s(literal 1/10 binary64)) #<representation binary64>) () ())
#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())
#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())
#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())
#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())
#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation binary64>) () ())
#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())
Outputs
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/8 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/24 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/8 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10)))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10)))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10)))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* 2 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -8/3 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 2 (/ 1 (* (pow re 4) (log 1/10)))))) (* 2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10))))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6))))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6))))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2))))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2))))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (patch (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt im (taylor -inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (patch (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) (patch (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log im)) (taylor 0 im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log im)) (taylor 0 im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log im)) (taylor 0 im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log im)) (taylor 0 im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 im)) (taylor inf im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 im)) (taylor inf im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 im)) (taylor inf im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 im)) (taylor inf im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (neg.f64 (log.f64 im)) (patch (neg.f64 (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow re 2)) (log 10))) (taylor 0 im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor 0 im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow im 2)) (log 10))) (taylor 0 re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor 0 re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (log (pow re 2))) (taylor 0 im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (log (pow im 2))) (taylor 0 re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (patch (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (log (pow re 2)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (log (pow im 2)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (*.f64 re re))) (patch (log.f64 (fma.f64 im im (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 im im (*.f64 re re)) (patch (fma.f64 im im (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (/ (log (pow im 2)) (log 1/10))) (taylor 0 re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (/ (log (pow re 2)) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (/ -2 (log (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (* 2 (/ (pow re 2) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ 1 (log (pow im 2))))) (taylor 0 re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2))))) (taylor 0 re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow re 2) (+ (* (pow re 2) (- (* (pow re 2) (- (+ (* 2/3 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 2)))) (/ 1 (* (pow im 6) (pow (log (pow im 2)) 3)))) (* -1 (/ (+ (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2))) (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3))))) (* (pow im 2) (log (pow im 2))))))) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2))))) (taylor 0 re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 re))) (taylor inf re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))) (taylor inf re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2)))) (pow re 4))) (/ 1 (log (/ 1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/6 (/ (pow im 6) (pow (log (/ 1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 6))) (/ 1 (log (/ 1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2))))))) (taylor inf re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ -1 re))) (taylor -inf re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))) (taylor -inf re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2)))) (pow re 4))) (/ 1 (log (/ -1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/6 (/ (pow im 6) (pow (log (/ -1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 6))) (/ 1 (log (/ -1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2))))))) (taylor -inf re) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (/ -2 (log (pow re 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (* 2 (/ (pow im 2) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ 1 (log (pow re 2))))) (taylor 0 im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2))))) (taylor 0 im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (- (+ (* 2/3 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 2)))) (/ 1 (* (pow re 6) (pow (log (pow re 2)) 3)))) (* -1 (/ (+ (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2))) (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3))))) (* (pow re 2) (log (pow re 2))))))) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2))))) (taylor 0 im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 im))) (taylor inf im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2)))) (pow im 4))) (/ 1 (log (/ 1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/6 (/ (pow re 6) (pow (log (/ 1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 6))) (/ 1 (log (/ 1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2))))))) (taylor inf im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ -1 im))) (taylor -inf im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2)))) (pow im 4))) (/ 1 (log (/ -1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/6 (/ (pow re 6) (pow (log (/ -1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 6))) (/ 1 (log (/ -1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2))))))) (taylor -inf im) (#s(alt (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (patch (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/2 (log (pow im 6))) (* 1/2 (log (pow im 4)))) (taylor 0 re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1/4 (* (pow re 2) (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))) (* 1/2 (log (pow im 6)))) (* 1/2 (log (pow im 4)))) (taylor 0 re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (log (pow im 6))) (* (pow re 2) (- (* -1/12 (* re (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))))) (* 1/4 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))))) (* 1/2 (log (pow im 4)))) (taylor 0 re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (log (pow im 6))) (* (pow re 2) (- (* re (- (* -1/48 (* re (+ (* -24 (/ (pow (+ im (* -1 im)) 2) (pow im 6))) (+ (* -6 (/ (pow (+ im (* -1 im)) 4) (pow im 8))) (* 12 (/ 1 (pow im 4))))))) (* 1/12 (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4))))))) (* 1/4 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))))) (* 1/2 (log (pow im 4)))) (taylor 0 re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (* -3 (log (/ 1 re))) (* -2 (log (/ 1 re)))) (taylor inf re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (* -2 (log (/ 1 re)))) (taylor inf re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ 1 re))) (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))) (+ (* -2 (log (/ 1 re))) (* -1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ 1 re))) (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))) (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/2 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))))) (taylor inf re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (* -3 (log (/ -1 re))) (* -2 (log (/ -1 re)))) (taylor -inf re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (* -2 (log (/ -1 re)))) (taylor -inf re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ -1 re))) (* 1/2 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))) (+ (* -2 (log (/ -1 re))) (* -1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ -1 re))) (* -1 (/ (- (* 1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) re)) (* 1/2 (* (pow im 2) (+ im (* -1 im))))) (pow re 3)))) (+ (* -2 (log (/ -1 re))) (* -1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/2 (log (pow re 6))) (* 1/2 (log (pow re 4)))) (taylor 0 im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (log (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))) (* 1/2 (log (pow re 4)))) (taylor 0 im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (log (pow re 6))) (* (pow im 2) (+ (* -1/2 (/ (* im (+ re (* -1 re))) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (* 1/2 (log (pow re 4)))) (taylor 0 im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (log (pow re 6))) (* (pow im 2) (+ (* im (- (* -1/4 (/ im (pow re 4))) (* 1/2 (/ (+ re (* -1 re)) (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (* 1/2 (log (pow re 4)))) (taylor 0 im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (* -3 (log (/ 1 im))) (* -2 (log (/ 1 im)))) (taylor inf im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ 1 im))) (* -1/2 (/ (+ re (* -1 re)) im))) (* -2 (log (/ 1 im)))) (taylor inf im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ 1 im))) (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2)))) (+ (* -2 (log (/ 1 im))) (* 1/2 (/ (+ re (* -1 re)) im)))) (taylor inf im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ 1 im))) (* -1/12 (/ (+ (* 2 (pow (+ re (* -1 re)) 3)) (* 6 (* (pow re 2) (+ re (* -1 re))))) (pow im 3)))) (+ (* -2 (log (/ 1 im))) (+ (* 1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2))) (* 1/2 (/ (+ re (* -1 re)) im))))) (taylor inf im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (* -3 (log (/ -1 im))) (* -2 (log (/ -1 im)))) (taylor -inf im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ -1 im))) (* -1/2 (/ (+ re (* -1 re)) im))) (* -2 (log (/ -1 im)))) (taylor -inf im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ -1 im))) (* -1 (/ (- (* 1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) im)) (* -1/2 (+ re (* -1 re)))) im))) (* -2 (log (/ -1 im)))) (taylor -inf im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (log (/ -1 im))) (* -1 (/ (- (* -1 (/ (- (* 1/12 (/ (+ (* -6 (* (pow re 2) (+ re (* -1 re)))) (* -2 (pow (+ re (* -1 re)) 3))) im)) (* 1/4 (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))))) im)) (* -1/2 (+ re (* -1 re)))) im))) (* -2 (log (/ -1 im)))) (taylor -inf im) (#s(alt (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (patch (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) #<representation binary64>) () ())) ())
#s(alt (/ (- (* 1/2 (log (pow im 6))) (* 1/2 (log (pow im 4)))) (log 10)) (taylor 0 re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1/4 (/ (* (pow re 2) (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2))))) (log 10))) (* 1/2 (/ (log (pow im 6)) (log 10)))) (* 1/2 (/ (log (pow im 4)) (log 10)))) (taylor 0 re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (/ (log (pow im 6)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))) (log 10))) (* -1/12 (/ (* re (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4))))) (log 10)))))) (* 1/2 (/ (log (pow im 4)) (log 10)))) (taylor 0 re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (/ (log (pow im 6)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))) (log 10))) (* re (+ (* -1/12 (/ (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))) (log 10))) (* -1/48 (/ (* re (+ (* -24 (/ (pow (+ im (* -1 im)) 2) (pow im 6))) (+ (* -6 (/ (pow (+ im (* -1 im)) 4) (pow im 8))) (* 12 (/ 1 (pow im 4)))))) (log 10)))))))) (* 1/2 (/ (log (pow im 4)) (log 10)))) (taylor 0 re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (- (* -3 (log (/ 1 re))) (* -2 (log (/ 1 re)))) (log 10)) (taylor inf re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (* -2 (/ (log (/ 1 re)) (log 10)))) (taylor inf re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ 1 re)) (log 10))) (+ (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (* (pow re 3) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (* -2 (/ (log (/ 1 re)) (log 10)))) (taylor inf re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ 1 re)) (log 10))) (+ (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (* (pow re 3) (log 10)))) (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (* -2 (/ (log (/ 1 re)) (log 10)))) (taylor inf re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (- (* -3 (log (/ -1 re))) (* -2 (log (/ -1 re)))) (log 10)) (taylor -inf re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (* -2 (/ (log (/ -1 re)) (log 10)))) (taylor -inf re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ -1 re)) (log 10))) (+ (* 1/2 (/ (* (pow im 2) (+ im (* -1 im))) (* (pow re 3) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (* -2 (/ (log (/ -1 re)) (log 10)))) (taylor -inf re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ -1 re)) (log 10))) (+ (* -1 (/ (+ (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (log 10))) (* 1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* re (log 10))))) (pow re 3))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (* -2 (/ (log (/ -1 re)) (log 10)))) (taylor -inf re) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (- (* 1/2 (log (pow re 6))) (* 1/2 (log (pow re 4)))) (log 10)) (taylor 0 im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (/ (log (pow re 6)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (* 1/2 (/ (log (pow re 4)) (log 10)))) (taylor 0 im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (/ (log (pow re 6)) (log 10))) (* (pow im 2) (+ (* -1/2 (/ (* im (+ re (* -1 re))) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (* 1/2 (/ (log (pow re 4)) (log 10)))) (taylor 0 im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* 1/2 (/ (log (pow re 6)) (log 10))) (* (pow im 2) (+ (* im (+ (* -1/2 (/ (+ re (* -1 re)) (* (pow re 4) (log 10)))) (* -1/4 (/ im (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (* 1/2 (/ (log (pow re 4)) (log 10)))) (taylor 0 im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (- (* -3 (log (/ 1 im))) (* -2 (log (/ 1 im)))) (log 10)) (taylor inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ 1 im)) (log 10))) (* -1/2 (/ (+ re (* -1 re)) (* im (log 10))))) (* -2 (/ (log (/ 1 im)) (log 10)))) (taylor inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ 1 im)) (log 10))) (+ (* -1/2 (/ (+ re (* -1 re)) (* im (log 10)))) (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (* (pow im 2) (log 10)))))) (* -2 (/ (log (/ 1 im)) (log 10)))) (taylor inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ 1 im)) (log 10))) (+ (* -1/2 (/ (+ re (* -1 re)) (* im (log 10)))) (+ (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (* (pow im 2) (log 10)))) (* -1/12 (/ (+ (* 2 (pow (+ re (* -1 re)) 3)) (* 6 (* (pow re 2) (+ re (* -1 re))))) (* (pow im 3) (log 10))))))) (* -2 (/ (log (/ 1 im)) (log 10)))) (taylor inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (- (* -3 (log (/ -1 im))) (* -2 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ -1 im)) (log 10))) (* -1/2 (/ (+ re (* -1 re)) (* im (log 10))))) (* -2 (/ (log (/ -1 im)) (log 10)))) (taylor -inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ -1 im)) (log 10))) (* -1 (/ (+ (* 1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (* im (log 10)))) (* 1/2 (/ (+ re (* -1 re)) (log 10)))) im))) (* -2 (/ (log (/ -1 im)) (log 10)))) (taylor -inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -3 (/ (log (/ -1 im)) (log 10))) (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (log 10))) (* 1/12 (/ (+ (* -6 (* (pow re 2) (+ re (* -1 re)))) (* -2 (pow (+ re (* -1 re)) 3))) (* im (log 10))))) im)) (* 1/2 (/ (+ re (* -1 re)) (log 10)))) im))) (* -2 (/ (log (/ -1 im)) (log 10)))) (taylor -inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (log (pow im 6))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 6))) (* 1/2 (/ (pow re 6) (pow im 6)))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 6))) (* (pow re 6) (+ (* -1/4 (/ (pow re 6) (pow im 12))) (* 1/2 (/ 1 (pow im 6)))))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 6))) (* (pow re 6) (+ (* (pow re 6) (- (* 1/6 (/ (pow re 6) (pow im 18))) (* 1/4 (/ 1 (pow im 12))))) (* 1/2 (/ 1 (pow im 6)))))) (taylor 0 re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (* -3 (log (/ 1 re))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ 1 re))) (* 1/2 (/ (pow im 6) (pow re 6)))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (* 1/2 (/ (pow im 6) (pow re 6))))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (+ (* 1/6 (/ (pow im 18) (pow re 18))) (* 1/2 (/ (pow im 6) (pow re 6)))))) (taylor inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (* -3 (log (/ -1 re))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ -1 re))) (* 1/2 (/ (pow im 6) (pow re 6)))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (* 1/2 (/ (pow im 6) (pow re 6))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (+ (* 1/6 (/ (pow im 18) (pow re 18))) (* 1/2 (/ (pow im 6) (pow re 6)))))) (taylor -inf re) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (log (pow re 6))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 6))) (* 1/2 (/ (pow im 6) (pow re 6)))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 6))) (* (pow im 6) (+ (* -1/4 (/ (pow im 6) (pow re 12))) (* 1/2 (/ 1 (pow re 6)))))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 6))) (* (pow im 6) (+ (* (pow im 6) (- (* 1/6 (/ (pow im 6) (pow re 18))) (* 1/4 (/ 1 (pow re 12))))) (* 1/2 (/ 1 (pow re 6)))))) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (* -3 (log (/ 1 im))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ 1 im))) (* 1/2 (/ (pow re 6) (pow im 6)))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (* 1/2 (/ (pow re 6) (pow im 6))))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (+ (* 1/6 (/ (pow re 18) (pow im 18))) (* 1/2 (/ (pow re 6) (pow im 6)))))) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (* -3 (log (/ -1 im))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ -1 im))) (* 1/2 (/ (pow re 6) (pow im 6)))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (* 1/2 (/ (pow re 6) (pow im 6))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -3 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (+ (* 1/6 (/ (pow re 18) (pow im 18))) (* 1/2 (/ (pow re 6) (pow im 6)))))) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (patch (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (log (pow im 6)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 6)) (/ (pow re 6) (pow im 6))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 6)) (* (pow re 6) (+ (* -1/2 (/ (pow re 6) (pow im 12))) (/ 1 (pow im 6))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (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))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* -6 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -6 (log (/ 1 re))) (/ (pow im 6) (pow re 6))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* -6 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -6 (log (/ -1 re))) (/ (pow im 6) (pow re 6))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (log (pow re 6)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 6)) (/ (pow im 6) (pow re 6))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 6)) (* (pow im 6) (+ (* -1/2 (/ (pow im 6) (pow re 12))) (/ 1 (pow re 6))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (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))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* -6 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -6 (log (/ 1 im))) (/ (pow re 6) (pow im 6))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* -6 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -6 (log (/ -1 im))) (/ (pow re 6) (pow im 6))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -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))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (log (pow im 2)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (log (pow re 2)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (log (pow im 4)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 4)) (* 1/2 (* (pow re 2) (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2))))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 4)) (* (pow re 2) (+ (* 1/6 (* re (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))))) (* 1/2 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 4)) (* (pow re 2) (+ (* 1/2 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2))))) (* re (+ (* 1/24 (* re (+ (* -24 (/ (pow (+ im (* -1 im)) 2) (pow im 6))) (+ (* -6 (/ (pow (+ im (* -1 im)) 4) (pow im 8))) (* 12 (/ 1 (pow im 4))))))) (* 1/6 (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))))))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (* -4 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (* -4 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3))) (* -1 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (+ (* -1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) re)) (* (pow im 2) (+ im (* -1 im)))) (pow re 3))) (* -1 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (log (pow re 4)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 4)) (* -1 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 4)) (* (pow im 2) (- (/ (* im (+ re (* -1 re))) (pow re 4)) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 4)) (* (pow im 2) (- (* im (+ (* 1/2 (/ im (pow re 4))) (+ (/ -1 (pow re 3)) (/ 1 (pow re 3))))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (* -4 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ re im)) (/ re im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ re im)) (+ (* 1/2 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2))) (/ re im)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ 1 im))) (+ (* -1 (/ re im)) (+ (* 1/6 (/ (+ (* 2 (pow (+ re (* -1 re)) 3)) (* 6 (* (pow re 2) (+ re (* -1 re))))) (pow im 3))) (+ (* 1/2 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2))) (/ re im))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (* -4 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ -1 im))) (+ (* -1 (/ re im)) (/ re im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ -1 im))) (* -1 (/ (+ (* -1 (+ re (* -1 re))) (* -1/2 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) im))) im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -4 (log (/ -1 im))) (* -1 (/ (+ (* -1 (+ re (* -1 re))) (* -1 (/ (+ (* -1/6 (/ (+ (* -6 (* (pow re 2) (+ re (* -1 re)))) (* -2 (pow (+ re (* -1 re)) 3))) im)) (* 1/2 (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))))) im))) im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (patch (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #<representation binary64>) () ())) ())
Calls

108 calls:

TimeVariablePointExpression
31.0ms
im
@0
(/ (neg (log im)) (log 1/10))
21.0ms
re
@inf
(* 1/2 (log (+ (* re (* re (* re (* re (* re re))))) (* (* im (* im im)) (* im (* im im))))))
17.0ms
re
@0
(* 1/2 (log (+ (* re (* re (* re (* re (* re re))))) (* (* im (* im im)) (* im (* im im))))))
16.0ms
im
@inf
(* 1/2 (log (+ (* re (* re (* re (* re (* re re))))) (* (* im (* im im)) (* im (* im im))))))
16.0ms
im
@0
(* 1/2 (log (+ (* re (* re (* re (* re (* re re))))) (* (* im (* im im)) (* im (* im im))))))

rewrite395.0ms (1.5%)

Memory
3.8MiB live, 632.9MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 816×lower-fma.f32
5 806×lower-fma.f64
4 396×lower-/.f32
4 382×lower-/.f64
4 300×lower-*.f32
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
046285
087188
1294170
21957170
08398170
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
23 → 969
Calls
Call 1
Inputs
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 im))
(log.f64 im)
(log.f64 #s(literal 1/10 binary64))
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 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 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))
(log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))
(log.f64 #s(literal 10 binary64))
(*.f64 re re)
(log.f64 (fma.f64 re re (*.f64 im im)))
(log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
Outputs
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 (log.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (log.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))))
(/.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal 1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal 1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64)))))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) #s(literal -1 binary64))
(*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))))
(*.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(+.f64 (log.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))))))))
(+.f64 (log.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(-.f64 (log.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (log.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))))
(-.f64 (log.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (log.f64 (fma.f64 im im (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (*.f64 re im))))))
(-.f64 (log.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(-.f64 (log.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (log.f64 (neg.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))))))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))) (log.f64 (neg.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(-.f64 (log.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))))) (log.f64 (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (log.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (fma.f64 (log.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))) (log.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))) (*.f64 (log.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (log.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) #s(literal 3 binary64))) (fma.f64 (log.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (log.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (fma.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (log.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))))
(+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) im)
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(-.f64 (/.f64 (*.f64 im im) (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))
(fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 im #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(fma.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) re im)
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 #s(literal 1 binary64) im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (*.f64 re (*.f64 re #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 (*.f64 (*.f64 re re) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (neg.f64 im)) im)
(fma.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) re) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (/.f64 re im) (/.f64 re #s(literal 2 binary64)) im)
(fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im)
(fma.f64 (/.f64 (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im) im)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im im (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (*.f64 re im)))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (-.f64 (*.f64 im im) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))))))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (fma.f64 im im (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (*.f64 re im)))))
(/.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 im im (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (*.f64 re im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (neg.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(/.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im)))) (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (neg.f64 (neg.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))) (neg.f64 (neg.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(/.f64 (neg.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))))) (neg.f64 (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (fma.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))))
(*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (*.f64 re im))))))
(*.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(*.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/8 binary64) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))) (*.f64 im (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64)))))))))
(*.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(*.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 #s(literal 1 binary64) (-.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))))
(/.f64 re (*.f64 im #s(literal 2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 im #s(literal 2 binary64)) re))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 im) (*.f64 re #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 #s(literal 1 binary64) re)))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 im) (*.f64 #s(literal -1/2 binary64) re)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 re) (neg.f64 (*.f64 im #s(literal 2 binary64))))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 (neg.f64 (*.f64 re #s(literal 1/2 binary64))) (neg.f64 im))
(/.f64 (*.f64 re #s(literal 1 binary64)) (*.f64 im #s(literal 2 binary64)))
(/.f64 (*.f64 re #s(literal -1/2 binary64)) (neg.f64 im))
(/.f64 (*.f64 #s(literal 1 binary64) re) (*.f64 im #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal -1/2 binary64) re) (neg.f64 im))
(/.f64 (neg.f64 (neg.f64 (*.f64 re #s(literal 1/2 binary64)))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (*.f64 re #s(literal 1 binary64))) (neg.f64 (*.f64 im #s(literal 2 binary64))))
(/.f64 (neg.f64 (*.f64 re #s(literal -1/2 binary64))) (neg.f64 (neg.f64 im)))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) re)) (neg.f64 (*.f64 im #s(literal 2 binary64))))
(/.f64 (neg.f64 (*.f64 #s(literal -1/2 binary64) re)) (neg.f64 (neg.f64 im)))
(pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) im) re))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) re)
(*.f64 #s(literal 1 binary64) (/.f64 re (*.f64 im #s(literal 2 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 re #s(literal 2 binary64)))
(*.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im))
(*.f64 (neg.f64 (*.f64 re #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 im)))
(*.f64 (*.f64 re #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (neg.f64 im)))
(*.f64 (*.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 (*.f64 #s(literal -1/2 binary64) re) (/.f64 #s(literal 1 binary64) (neg.f64 im)))
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(*.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (*.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (*.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(log.f64 (/.f64 #s(literal 1 binary64) im))
(+.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im)))
(-.f64 #s(literal 0 binary64) (log.f64 im))
(-.f64 #s(literal 0 binary64) (/.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64)))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 im)))
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 im))))) (/.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 im))))))
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) (log.f64 im))) (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (log.f64 im))))
(neg.f64 (log.f64 im))
(/.f64 (log.f64 im) #s(literal -1 binary64))
(/.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 im)))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 0 binary64) (log.f64 im)) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (+.f64 #s(literal 0 binary64) (log.f64 im)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 im))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(literal 0 binary64) (log.f64 im))))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im))))))
(*.f64 (log.f64 im) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 im))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 im))))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 0 binary64) (log.f64 im))))
(log.f64 im)
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im)))
(neg.f64 (neg.f64 (log.f64 im)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im))))))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(log.f64 #s(literal 1/10 binary64))
(exp.f64 (neg.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(+.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (/.f64 (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))) (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 #s(literal 1 binary64) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(neg.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64))) (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))) (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))
(/.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (-.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) #s(literal 1 binary64))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64))
(/.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (-.f64 (*.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1/2 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 #s(literal -1/2 binary64) (pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal -1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))) #s(literal -1/2 binary64))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1 binary64))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (pow.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal -2 binary64)))
(*.f64 (/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal -1 binary64)))
(*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal -2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))
(+.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(-.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(-.f64 (/.f64 (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))
(fma.f64 #s(literal 1/2 binary64) (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 1/2 binary64) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))
(fma.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 #s(literal -1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1/2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (fma.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (neg.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)))) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))) (neg.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (fma.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64)) #s(literal -1/8 binary64) (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)))) (fma.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) #s(literal 3 binary64)) (pow.f64 (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (fma.f64 (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (*.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))))
(/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))))
(pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(*.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(*.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) #s(literal 1/2 binary64)) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(log.f64 (fma.f64 re re (*.f64 im im)))
(+.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(+.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(+.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(-.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (log.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (log.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(-.f64 (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)))) (neg.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (-.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (fma.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64))) (fma.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))))
(*.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(*.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)) (*.f64 re re))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))
(/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (neg.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (/.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) (/.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))))
(*.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))))
(*.f64 (/.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (/.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (/.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) (/.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))))
(*.f64 (/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)) (-.f64 im re))
(+.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (/.f64 (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))) (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 #s(literal 1 binary64) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(neg.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64))) (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))) (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))
(/.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (-.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) #s(literal 1 binary64))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64))
(/.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (-.f64 (*.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1/2 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 #s(literal -1/2 binary64) (pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal -1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))) #s(literal -1/2 binary64))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1 binary64))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (pow.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal -2 binary64)))
(*.f64 (/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal -1 binary64)))
(*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal -2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) #s(literal -1 binary64)))
(neg.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))))
(/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(/.f64 #s(literal 2 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 #s(literal -2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 #s(literal 2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))
(+.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(-.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(-.f64 (/.f64 (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))
(fma.f64 #s(literal 1/2 binary64) (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 1/2 binary64) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))
(fma.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 #s(literal -1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1/2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (fma.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (neg.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)))) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))) (neg.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (fma.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64)) #s(literal -1/8 binary64) (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)))) (fma.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) #s(literal 3 binary64)) (pow.f64 (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (fma.f64 (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (*.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))))
(/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))))
(pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(*.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(*.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) #s(literal 1/2 binary64)) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(+.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (/.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (/.f64 (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))) (/.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 2 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))) (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (/.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 #s(literal 1 binary64) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(fma.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(neg.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64))) (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))) (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))
(/.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))
(/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (-.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) #s(literal 1 binary64))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (*.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64))
(/.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))) (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (-.f64 (*.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 #s(literal -2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1/2 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(*.f64 #s(literal -1/2 binary64) (pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(*.f64 #s(literal -1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(*.f64 (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64)))))
(*.f64 (neg.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))) #s(literal -1/2 binary64))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1 binary64))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 #s(literal -1 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(*.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)))
(*.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)) (pow.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal -2 binary64)))
(*.f64 (/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal -1/2 binary64)) #s(literal 3 binary64))) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal -1 binary64)))
(*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal -2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) #s(literal 1/4 binary64)))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 1/2 binary64))
(log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))
(+.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) (log.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(+.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(+.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (log.f64 (fma.f64 re re (*.f64 im im))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(-.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(-.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (log.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))) (log.f64 (neg.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 (neg.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (-.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))
(neg.f64 (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))) (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (fma.f64 (log.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (-.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))))
(log.f64 #s(literal 10 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))))))
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))))))
(*.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))))
(exp.f64 (log.f64 (*.f64 re re)))
(pow.f64 re #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 2 binary64))
(*.f64 re re)
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(+.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(+.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(+.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(-.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (log.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (log.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(-.f64 (/.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (/.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)))) (neg.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (-.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (fma.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64))) (fma.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))))
(*.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))))
(*.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))
(+.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(+.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(-.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(-.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (log.f64 (fma.f64 im (*.f64 (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))))))))
(-.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))))))
(-.f64 (log.f64 (neg.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re))))))))) (log.f64 (neg.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))))))) (log.f64 (neg.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))))
(-.f64 (log.f64 (-.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))) (log.f64 (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re))))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re))))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (fma.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re))))))) (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (-.f64 (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))) (*.f64 re (*.f64 re (*.f64 re re)))))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) (log.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) (fma.f64 (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))))) (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im))))) (*.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))) (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 (*.f64 im (-.f64 im re)) (+.f64 re im)))))))))

simplify578.0ms (2.2%)

Memory
51.4MiB live, 717.2MiB allocated
Algorithm
1×egg-herbie
Rules
12 724×lower-fma.f64
12 724×lower-fma.f32
6 418×lower-+.f64
6 418×lower-+.f32
5 818×lower-*.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
012089295
135988385
092467963
Stop Event
1×iter limit
1×node limit
Counts
432 → 429
Calls
Call 1
Inputs
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/8 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/24 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/8 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))
(+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))
(* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))
(+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))
(* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))))
(+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* 2 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -8/3 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 2 (/ 1 (* (pow re 4) (log 1/10)))))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10))))))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (log im))
(* -1 (log im))
(* -1 (log im))
(* -1 (log im))
(log (/ 1 im))
(log (/ 1 im))
(log (/ 1 im))
(log (/ 1 im))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* 1/2 (log (pow re 2)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* 1/2 (log (pow im 2)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(/ -2 (log (pow im 2)))
(- (* 2 (/ (pow re 2) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ 1 (log (pow im 2)))))
(- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(- (* (pow re 2) (+ (* (pow re 2) (- (* (pow re 2) (- (+ (* 2/3 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 2)))) (/ 1 (* (pow im 6) (pow (log (pow im 2)) 3)))) (* -1 (/ (+ (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2))) (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3))))) (* (pow im 2) (log (pow im 2))))))) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(/ 1 (log (/ 1 re)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(- (+ (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2)))) (pow re 4))) (/ 1 (log (/ 1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(- (+ (* -1 (/ (+ (* -1/6 (/ (pow im 6) (pow (log (/ 1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 6))) (/ 1 (log (/ 1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))))))
(/ 1 (log (/ -1 re)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(- (+ (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2)))) (pow re 4))) (/ 1 (log (/ -1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(- (+ (* -1 (/ (+ (* -1/6 (/ (pow im 6) (pow (log (/ -1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 6))) (/ 1 (log (/ -1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))))))
(/ -2 (log (pow re 2)))
(- (* 2 (/ (pow im 2) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ 1 (log (pow re 2)))))
(- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(- (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (- (+ (* 2/3 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 2)))) (/ 1 (* (pow re 6) (pow (log (pow re 2)) 3)))) (* -1 (/ (+ (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2))) (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3))))) (* (pow re 2) (log (pow re 2))))))) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(/ 1 (log (/ 1 im)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(- (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2)))) (pow im 4))) (/ 1 (log (/ 1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (+ (* -1/6 (/ (pow re 6) (pow (log (/ 1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 6))) (/ 1 (log (/ 1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))))))
(/ 1 (log (/ -1 im)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(- (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2)))) (pow im 4))) (/ 1 (log (/ -1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(- (+ (* -1 (/ (+ (* -1/6 (/ (pow re 6) (pow (log (/ -1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 6))) (/ 1 (log (/ -1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))))))
(- (* 1/2 (log (pow im 6))) (* 1/2 (log (pow im 4))))
(- (+ (* -1/4 (* (pow re 2) (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))) (* 1/2 (log (pow im 6)))) (* 1/2 (log (pow im 4))))
(- (+ (* 1/2 (log (pow im 6))) (* (pow re 2) (- (* -1/12 (* re (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))))) (* 1/4 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))))) (* 1/2 (log (pow im 4))))
(- (+ (* 1/2 (log (pow im 6))) (* (pow re 2) (- (* re (- (* -1/48 (* re (+ (* -24 (/ (pow (+ im (* -1 im)) 2) (pow im 6))) (+ (* -6 (/ (pow (+ im (* -1 im)) 4) (pow im 8))) (* 12 (/ 1 (pow im 4))))))) (* 1/12 (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4))))))) (* 1/4 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))))) (* 1/2 (log (pow im 4))))
(- (* -3 (log (/ 1 re))) (* -2 (log (/ 1 re))))
(- (+ (* -3 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (* -2 (log (/ 1 re))))
(- (+ (* -3 (log (/ 1 re))) (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))) (+ (* -2 (log (/ 1 re))) (* -1/2 (/ (pow im 2) (pow re 2)))))
(- (+ (* -3 (log (/ 1 re))) (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))) (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/2 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3))))))
(- (* -3 (log (/ -1 re))) (* -2 (log (/ -1 re))))
(- (+ (* -3 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (* -2 (log (/ -1 re))))
(- (+ (* -3 (log (/ -1 re))) (* 1/2 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))) (+ (* -2 (log (/ -1 re))) (* -1/2 (/ (pow im 2) (pow re 2)))))
(- (+ (* -3 (log (/ -1 re))) (* -1 (/ (- (* 1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) re)) (* 1/2 (* (pow im 2) (+ im (* -1 im))))) (pow re 3)))) (+ (* -2 (log (/ -1 re))) (* -1/2 (/ (pow im 2) (pow re 2)))))
(- (* 1/2 (log (pow re 6))) (* 1/2 (log (pow re 4))))
(- (+ (* 1/2 (log (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))) (* 1/2 (log (pow re 4))))
(- (+ (* 1/2 (log (pow re 6))) (* (pow im 2) (+ (* -1/2 (/ (* im (+ re (* -1 re))) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (* 1/2 (log (pow re 4))))
(- (+ (* 1/2 (log (pow re 6))) (* (pow im 2) (+ (* im (- (* -1/4 (/ im (pow re 4))) (* 1/2 (/ (+ re (* -1 re)) (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (* 1/2 (log (pow re 4))))
(- (* -3 (log (/ 1 im))) (* -2 (log (/ 1 im))))
(- (+ (* -3 (log (/ 1 im))) (* -1/2 (/ (+ re (* -1 re)) im))) (* -2 (log (/ 1 im))))
(- (+ (* -3 (log (/ 1 im))) (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2)))) (+ (* -2 (log (/ 1 im))) (* 1/2 (/ (+ re (* -1 re)) im))))
(- (+ (* -3 (log (/ 1 im))) (* -1/12 (/ (+ (* 2 (pow (+ re (* -1 re)) 3)) (* 6 (* (pow re 2) (+ re (* -1 re))))) (pow im 3)))) (+ (* -2 (log (/ 1 im))) (+ (* 1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2))) (* 1/2 (/ (+ re (* -1 re)) im)))))
(- (* -3 (log (/ -1 im))) (* -2 (log (/ -1 im))))
(- (+ (* -3 (log (/ -1 im))) (* -1/2 (/ (+ re (* -1 re)) im))) (* -2 (log (/ -1 im))))
(- (+ (* -3 (log (/ -1 im))) (* -1 (/ (- (* 1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) im)) (* -1/2 (+ re (* -1 re)))) im))) (* -2 (log (/ -1 im))))
(- (+ (* -3 (log (/ -1 im))) (* -1 (/ (- (* -1 (/ (- (* 1/12 (/ (+ (* -6 (* (pow re 2) (+ re (* -1 re)))) (* -2 (pow (+ re (* -1 re)) 3))) im)) (* 1/4 (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))))) im)) (* -1/2 (+ re (* -1 re)))) im))) (* -2 (log (/ -1 im))))
(/ (- (* 1/2 (log (pow im 6))) (* 1/2 (log (pow im 4)))) (log 10))
(- (+ (* -1/4 (/ (* (pow re 2) (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2))))) (log 10))) (* 1/2 (/ (log (pow im 6)) (log 10)))) (* 1/2 (/ (log (pow im 4)) (log 10))))
(- (+ (* 1/2 (/ (log (pow im 6)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))) (log 10))) (* -1/12 (/ (* re (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4))))) (log 10)))))) (* 1/2 (/ (log (pow im 4)) (log 10))))
(- (+ (* 1/2 (/ (log (pow im 6)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))) (log 10))) (* re (+ (* -1/12 (/ (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))) (log 10))) (* -1/48 (/ (* re (+ (* -24 (/ (pow (+ im (* -1 im)) 2) (pow im 6))) (+ (* -6 (/ (pow (+ im (* -1 im)) 4) (pow im 8))) (* 12 (/ 1 (pow im 4)))))) (log 10)))))))) (* 1/2 (/ (log (pow im 4)) (log 10))))
(/ (- (* -3 (log (/ 1 re))) (* -2 (log (/ 1 re)))) (log 10))
(- (+ (* -3 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (* -2 (/ (log (/ 1 re)) (log 10))))
(- (+ (* -3 (/ (log (/ 1 re)) (log 10))) (+ (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (* (pow re 3) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (* -2 (/ (log (/ 1 re)) (log 10))))
(- (+ (* -3 (/ (log (/ 1 re)) (log 10))) (+ (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (* (pow re 3) (log 10)))) (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (* -2 (/ (log (/ 1 re)) (log 10))))
(/ (- (* -3 (log (/ -1 re))) (* -2 (log (/ -1 re)))) (log 10))
(- (+ (* -3 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (* -2 (/ (log (/ -1 re)) (log 10))))
(- (+ (* -3 (/ (log (/ -1 re)) (log 10))) (+ (* 1/2 (/ (* (pow im 2) (+ im (* -1 im))) (* (pow re 3) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (* -2 (/ (log (/ -1 re)) (log 10))))
(- (+ (* -3 (/ (log (/ -1 re)) (log 10))) (+ (* -1 (/ (+ (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (log 10))) (* 1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* re (log 10))))) (pow re 3))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (* -2 (/ (log (/ -1 re)) (log 10))))
(/ (- (* 1/2 (log (pow re 6))) (* 1/2 (log (pow re 4)))) (log 10))
(- (+ (* 1/2 (/ (log (pow re 6)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (* 1/2 (/ (log (pow re 4)) (log 10))))
(- (+ (* 1/2 (/ (log (pow re 6)) (log 10))) (* (pow im 2) (+ (* -1/2 (/ (* im (+ re (* -1 re))) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (* 1/2 (/ (log (pow re 4)) (log 10))))
(- (+ (* 1/2 (/ (log (pow re 6)) (log 10))) (* (pow im 2) (+ (* im (+ (* -1/2 (/ (+ re (* -1 re)) (* (pow re 4) (log 10)))) (* -1/4 (/ im (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (* 1/2 (/ (log (pow re 4)) (log 10))))
(/ (- (* -3 (log (/ 1 im))) (* -2 (log (/ 1 im)))) (log 10))
(- (+ (* -3 (/ (log (/ 1 im)) (log 10))) (* -1/2 (/ (+ re (* -1 re)) (* im (log 10))))) (* -2 (/ (log (/ 1 im)) (log 10))))
(- (+ (* -3 (/ (log (/ 1 im)) (log 10))) (+ (* -1/2 (/ (+ re (* -1 re)) (* im (log 10)))) (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (* (pow im 2) (log 10)))))) (* -2 (/ (log (/ 1 im)) (log 10))))
(- (+ (* -3 (/ (log (/ 1 im)) (log 10))) (+ (* -1/2 (/ (+ re (* -1 re)) (* im (log 10)))) (+ (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (* (pow im 2) (log 10)))) (* -1/12 (/ (+ (* 2 (pow (+ re (* -1 re)) 3)) (* 6 (* (pow re 2) (+ re (* -1 re))))) (* (pow im 3) (log 10))))))) (* -2 (/ (log (/ 1 im)) (log 10))))
(/ (- (* -3 (log (/ -1 im))) (* -2 (log (/ -1 im)))) (log 10))
(- (+ (* -3 (/ (log (/ -1 im)) (log 10))) (* -1/2 (/ (+ re (* -1 re)) (* im (log 10))))) (* -2 (/ (log (/ -1 im)) (log 10))))
(- (+ (* -3 (/ (log (/ -1 im)) (log 10))) (* -1 (/ (+ (* 1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (* im (log 10)))) (* 1/2 (/ (+ re (* -1 re)) (log 10)))) im))) (* -2 (/ (log (/ -1 im)) (log 10))))
(- (+ (* -3 (/ (log (/ -1 im)) (log 10))) (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (log 10))) (* 1/12 (/ (+ (* -6 (* (pow re 2) (+ re (* -1 re)))) (* -2 (pow (+ re (* -1 re)) 3))) (* im (log 10))))) im)) (* 1/2 (/ (+ re (* -1 re)) (log 10)))) im))) (* -2 (/ (log (/ -1 im)) (log 10))))
(* 1/2 (log (pow im 6)))
(+ (* 1/2 (log (pow im 6))) (* 1/2 (/ (pow re 6) (pow im 6))))
(+ (* 1/2 (log (pow im 6))) (* (pow re 6) (+ (* -1/4 (/ (pow re 6) (pow im 12))) (* 1/2 (/ 1 (pow im 6))))))
(+ (* 1/2 (log (pow im 6))) (* (pow re 6) (+ (* (pow re 6) (- (* 1/6 (/ (pow re 6) (pow im 18))) (* 1/4 (/ 1 (pow im 12))))) (* 1/2 (/ 1 (pow im 6))))))
(* -3 (log (/ 1 re)))
(+ (* -3 (log (/ 1 re))) (* 1/2 (/ (pow im 6) (pow re 6))))
(+ (* -3 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (* 1/2 (/ (pow im 6) (pow re 6)))))
(+ (* -3 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (+ (* 1/6 (/ (pow im 18) (pow re 18))) (* 1/2 (/ (pow im 6) (pow re 6))))))
(* -3 (log (/ -1 re)))
(+ (* -3 (log (/ -1 re))) (* 1/2 (/ (pow im 6) (pow re 6))))
(+ (* -3 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (* 1/2 (/ (pow im 6) (pow re 6)))))
(+ (* -3 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (+ (* 1/6 (/ (pow im 18) (pow re 18))) (* 1/2 (/ (pow im 6) (pow re 6))))))
(* 1/2 (log (pow re 6)))
(+ (* 1/2 (log (pow re 6))) (* 1/2 (/ (pow im 6) (pow re 6))))
(+ (* 1/2 (log (pow re 6))) (* (pow im 6) (+ (* -1/4 (/ (pow im 6) (pow re 12))) (* 1/2 (/ 1 (pow re 6))))))
(+ (* 1/2 (log (pow re 6))) (* (pow im 6) (+ (* (pow im 6) (- (* 1/6 (/ (pow im 6) (pow re 18))) (* 1/4 (/ 1 (pow re 12))))) (* 1/2 (/ 1 (pow re 6))))))
(* -3 (log (/ 1 im)))
(+ (* -3 (log (/ 1 im))) (* 1/2 (/ (pow re 6) (pow im 6))))
(+ (* -3 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (* 1/2 (/ (pow re 6) (pow im 6)))))
(+ (* -3 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (+ (* 1/6 (/ (pow re 18) (pow im 18))) (* 1/2 (/ (pow re 6) (pow im 6))))))
(* -3 (log (/ -1 im)))
(+ (* -3 (log (/ -1 im))) (* 1/2 (/ (pow re 6) (pow im 6))))
(+ (* -3 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (* 1/2 (/ (pow re 6) (pow im 6)))))
(+ (* -3 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (+ (* 1/6 (/ (pow re 18) (pow im 18))) (* 1/2 (/ (pow re 6) (pow im 6))))))
(log (pow im 6))
(+ (log (pow im 6)) (/ (pow re 6) (pow im 6)))
(+ (log (pow im 6)) (* (pow re 6) (+ (* -1/2 (/ (pow re 6) (pow im 12))) (/ 1 (pow im 6)))))
(+ (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)))))
(* -6 (log (/ 1 re)))
(+ (* -6 (log (/ 1 re))) (/ (pow im 6) (pow re 6)))
(+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))
(+ (* -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)))))
(* -6 (log (/ -1 re)))
(+ (* -6 (log (/ -1 re))) (/ (pow im 6) (pow re 6)))
(+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))
(+ (* -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)))))
(log (pow re 6))
(+ (log (pow re 6)) (/ (pow im 6) (pow re 6)))
(+ (log (pow re 6)) (* (pow im 6) (+ (* -1/2 (/ (pow im 6) (pow re 12))) (/ 1 (pow re 6)))))
(+ (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)))))
(* -6 (log (/ 1 im)))
(+ (* -6 (log (/ 1 im))) (/ (pow re 6) (pow im 6)))
(+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))
(+ (* -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)))))
(* -6 (log (/ -1 im)))
(+ (* -6 (log (/ -1 im))) (/ (pow re 6) (pow im 6)))
(+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))
(+ (* -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)))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(log (pow im 4))
(+ (log (pow im 4)) (* 1/2 (* (pow re 2) (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))))
(+ (log (pow im 4)) (* (pow re 2) (+ (* 1/6 (* re (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))))) (* 1/2 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2))))))))
(+ (log (pow im 4)) (* (pow re 2) (+ (* 1/2 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2))))) (* re (+ (* 1/24 (* re (+ (* -24 (/ (pow (+ im (* -1 im)) 2) (pow im 6))) (+ (* -6 (/ (pow (+ im (* -1 im)) 4) (pow im 8))) (* 12 (/ 1 (pow im 4))))))) (* 1/6 (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4))))))))))
(* -4 (log (/ 1 re)))
(+ (* -4 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2))))
(+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3))))
(+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))))
(* -4 (log (/ -1 re)))
(+ (* -4 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2))))
(+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3))) (* -1 (/ (pow im 2) (pow re 2)))))
(+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (+ (* -1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) re)) (* (pow im 2) (+ im (* -1 im)))) (pow re 3))) (* -1 (/ (pow im 2) (pow re 2)))))
(log (pow re 4))
(+ (log (pow re 4)) (* -1 (/ (pow im 2) (pow re 2))))
(+ (log (pow re 4)) (* (pow im 2) (- (/ (* im (+ re (* -1 re))) (pow re 4)) (/ 1 (pow re 2)))))
(+ (log (pow re 4)) (* (pow im 2) (- (* im (+ (* 1/2 (/ im (pow re 4))) (+ (/ -1 (pow re 3)) (/ 1 (pow re 3))))) (/ 1 (pow re 2)))))
(* -4 (log (/ 1 im)))
(+ (* -4 (log (/ 1 im))) (+ (* -1 (/ re im)) (/ re im)))
(+ (* -4 (log (/ 1 im))) (+ (* -1 (/ re im)) (+ (* 1/2 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2))) (/ re im))))
(+ (* -4 (log (/ 1 im))) (+ (* -1 (/ re im)) (+ (* 1/6 (/ (+ (* 2 (pow (+ re (* -1 re)) 3)) (* 6 (* (pow re 2) (+ re (* -1 re))))) (pow im 3))) (+ (* 1/2 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2))) (/ re im)))))
(* -4 (log (/ -1 im)))
(+ (* -4 (log (/ -1 im))) (+ (* -1 (/ re im)) (/ re im)))
(+ (* -4 (log (/ -1 im))) (* -1 (/ (+ (* -1 (+ re (* -1 re))) (* -1/2 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) im))) im)))
(+ (* -4 (log (/ -1 im))) (* -1 (/ (+ (* -1 (+ re (* -1 re))) (* -1 (/ (+ (* -1/6 (/ (+ (* -6 (* (pow re 2) (+ re (* -1 re)))) (* -2 (pow (+ re (* -1 re)) 3))) im)) (* 1/2 (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))))) im))) im)))
Outputs
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/8 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/24 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/8 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/24 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 #s(literal 1/8 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))
(* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10)))
(/.f64 (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))))
(fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))
(fma.f64 #s(literal 2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))))
(+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))
(fma.f64 #s(literal -8/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))))
(* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10)))
(/.f64 (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))))
(fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))
(fma.f64 #s(literal 2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))))
(+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))
(fma.f64 #s(literal -8/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))))
(* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (log.f64 im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))))
(-.f64 (/.f64 (*.f64 #s(literal -2 binary64) (*.f64 im im)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (-.f64 (log.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* 2 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal -2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re)))) (/.f64 (-.f64 (log.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (log.f64 im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -8/3 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 2 (/ 1 (* (pow re 4) (log 1/10)))))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -8/3 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal 2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64))))) (/.f64 #s(literal -2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re)))) (/.f64 (-.f64 (log.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (log.f64 im)) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (fma.f64 #s(literal -1/24 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10))))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))))))
(-.f64 (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (fma.f64 #s(literal -1/24 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)))) (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/24 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal 8/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (+.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal 8/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(-.f64 (log.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (log.f64 im))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (-.f64 (log.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (log.f64 im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -2 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 2 binary64) (*.f64 re re))) (-.f64 (log.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (log.f64 im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 8/3 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -2 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 2 binary64) (*.f64 re re))) (-.f64 (log.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (log.f64 im)))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 im))) (/.f64 (*.f64 #s(literal 1/24 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal 1/24 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 re re) (*.f64 im im)) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 re re) (*.f64 im im)) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 re re) (*.f64 im im)) im)
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(*.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1 binary64)) (neg.f64 im))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(*.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1 binary64)) (neg.f64 im))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(*.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -1 binary64)) (neg.f64 im))
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (log im))
(neg.f64 (log.f64 im))
(* -1 (log im))
(neg.f64 (log.f64 im))
(* -1 (log im))
(neg.f64 (log.f64 im))
(* -1 (log im))
(neg.f64 (log.f64 im))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.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) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.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) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (fma.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/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.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) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.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) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* 1/2 (log (pow re 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* 1/2 (log (pow im 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (log.f64 re) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(* -2 (log (/ 1 im)))
(*.f64 #s(literal 2 binary64) (log.f64 im))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (/.f64 (*.f64 re re) (*.f64 im im)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 2 binary64) (log.f64 im) (/.f64 (*.f64 re re) (*.f64 im im))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
(* -2 (log (/ -1 im)))
(*.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 re re) (*.f64 im im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 re re) (*.f64 im im))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(* -2 (log (/ 1 re)))
(neg.f64 (*.f64 #s(literal -2 binary64) (log.f64 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 im im) (*.f64 re re))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
(* -2 (log (/ -1 re)))
(*.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (*.f64 im im) (*.f64 re re))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(*.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal -1/6 binary64) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(*.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64))))) (/.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re)))) (*.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(-.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/6 binary64) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(/ -2 (log (pow im 2)))
(/.f64 #s(literal -2 binary64) (log.f64 (*.f64 im im)))
(- (* 2 (/ (pow re 2) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ 1 (log (pow im 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))) (/.f64 #s(literal -2 binary64) (log.f64 (*.f64 im im))))
(- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (+.f64 (/.f64 #s(literal 2 binary64) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))))) (neg.f64 (*.f64 re re)) (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))))) (/.f64 #s(literal -2 binary64) (log.f64 (*.f64 im im))))
(- (* (pow re 2) (+ (* (pow re 2) (- (* (pow re 2) (- (+ (* 2/3 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 2)))) (/ 1 (* (pow im 6) (pow (log (pow im 2)) 3)))) (* -1 (/ (+ (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2))) (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3))))) (* (pow im 2) (log (pow im 2))))))) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (-.f64 (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))) (+.f64 (/.f64 #s(literal 2/3 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))) (/.f64 (+.f64 (/.f64 #s(literal 2 binary64) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))))) (*.f64 (*.f64 im im) (log.f64 (*.f64 im im))))))) (+.f64 (/.f64 #s(literal 2 binary64) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64)))))) (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (*.f64 im im)) #s(literal 2 binary64))))) (/.f64 #s(literal -2 binary64) (log.f64 (*.f64 im im))))
(/ 1 (log (/ 1 re)))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 re)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 re))))
(- (+ (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2)))) (pow re 4))) (/ 1 (log (/ 1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(+.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 re)))))
(- (+ (* -1 (/ (+ (* -1/6 (/ (pow im 6) (pow (log (/ 1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 6))) (/ 1 (log (/ 1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))))))
(-.f64 (-.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 re))) (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))))
(/ 1 (log (/ -1 re)))
(/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(- (+ (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2)))) (pow re 4))) (/ 1 (log (/ -1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(+.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (neg.f64 (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(- (+ (* -1 (/ (+ (* -1/6 (/ (pow im 6) (pow (log (/ -1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 6))) (/ 1 (log (/ -1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))))))
(-.f64 (-.f64 (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (/.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 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/8 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))))
(/ -2 (log (pow re 2)))
(/.f64 #s(literal -2 binary64) (log.f64 (*.f64 re re)))
(- (* 2 (/ (pow im 2) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ 1 (log (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))) (/.f64 #s(literal -2 binary64) (log.f64 (*.f64 re re))))
(- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (neg.f64 (+.f64 (/.f64 #s(literal 2 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))))) (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))))) (/.f64 #s(literal -2 binary64) (log.f64 (*.f64 re re))))
(- (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (- (+ (* 2/3 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 2)))) (/ 1 (* (pow re 6) (pow (log (pow re 2)) 3)))) (* -1 (/ (+ (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2))) (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3))))) (* (pow re 2) (log (pow re 2))))))) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (-.f64 (fma.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 2/3 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64)))) (+.f64 (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))) (/.f64 (+.f64 (/.f64 #s(literal 2 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))))) (*.f64 (*.f64 re re) (log.f64 (*.f64 re re)))))) (neg.f64 (/.f64 #s(literal 2 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 3 binary64)))))) (/.f64 #s(literal 1 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))))) (/.f64 #s(literal 2 binary64) (*.f64 (*.f64 re re) (pow.f64 (log.f64 (*.f64 re re)) #s(literal 2 binary64))))) (/.f64 #s(literal -2 binary64) (log.f64 (*.f64 re re))))
(/ 1 (log (/ 1 im)))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
(- (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2)))) (pow im 4))) (/ 1 (log (/ 1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(+.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (neg.f64 (pow.f64 im #s(literal 4 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(- (+ (* -1 (/ (+ (* -1/6 (/ (pow re 6) (pow (log (/ 1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 6))) (/ 1 (log (/ 1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))))))
(-.f64 (-.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (log.f64 im)) (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))))))
(/ 1 (log (/ -1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(- (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2)))) (pow im 4))) (/ 1 (log (/ -1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(+.f64 (neg.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 im #s(literal 4 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(- (+ (* -1 (/ (+ (* -1/6 (/ (pow re 6) (pow (log (/ -1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 6))) (/ 1 (log (/ -1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))))))
(-.f64 (-.f64 (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.f64 (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))))
(- (* 1/2 (log (pow im 6))) (* 1/2 (log (pow im 4))))
(*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 4 binary64)))))
(- (+ (* -1/4 (* (pow re 2) (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))) (* 1/2 (log (pow im 6)))) (* 1/2 (log (pow im 4))))
(fma.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 4 binary64))))))
(- (+ (* 1/2 (log (pow im 6))) (* (pow re 2) (- (* -1/12 (* re (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))))) (* 1/4 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))))) (* 1/2 (log (pow im 4))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/12 binary64) (*.f64 re (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 6 binary64))))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 4 binary64))))))
(- (+ (* 1/2 (log (pow im 6))) (* (pow re 2) (- (* re (- (* -1/48 (* re (+ (* -24 (/ (pow (+ im (* -1 im)) 2) (pow im 6))) (+ (* -6 (/ (pow (+ im (* -1 im)) 4) (pow im 8))) (* 12 (/ 1 (pow im 4))))))) (* 1/12 (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4))))))) (* 1/4 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))))) (* 1/2 (log (pow im 4))))
(fma.f64 (*.f64 re re) (fma.f64 re (fma.f64 (*.f64 #s(literal -1/48 binary64) re) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 8 binary64))) (+.f64 (/.f64 #s(literal 12 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 6 binary64))))) (*.f64 #s(literal -1/12 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 6 binary64)))))) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 4 binary64))))))
(- (* -3 (log (/ 1 re))) (* -2 (log (/ 1 re))))
(log.f64 re)
(- (+ (* -3 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (* -2 (log (/ 1 re))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 re))
(- (+ (* -3 (log (/ 1 re))) (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))) (+ (* -2 (log (/ 1 re))) (* -1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (+.f64 (/.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re))) (log.f64 re)) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))
(- (+ (* -3 (log (/ 1 re))) (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4)))) (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/2 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3))))))
(-.f64 (fma.f64 #s(literal -1/48 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal 12 binary64)) (pow.f64 re #s(literal 4 binary64))) (log.f64 re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re)))))
(- (* -3 (log (/ -1 re))) (* -2 (log (/ -1 re))))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(- (+ (* -3 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (* -2 (log (/ -1 re))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(- (+ (* -3 (log (/ -1 re))) (* 1/2 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))) (+ (* -2 (log (/ -1 re))) (* -1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (+.f64 (/.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))
(- (+ (* -3 (log (/ -1 re))) (* -1 (/ (- (* 1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) re)) (* 1/2 (* (pow im 2) (+ im (* -1 im))))) (pow re 3)))) (+ (* -2 (log (/ -1 re))) (* -1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (+.f64 (/.f64 (fma.f64 #s(literal 1/48 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal 12 binary64)) re) #s(literal 0 binary64)) (neg.f64 (*.f64 re (*.f64 re re)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)))
(- (* 1/2 (log (pow re 6))) (* 1/2 (log (pow re 4))))
(*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 re #s(literal 6 binary64))) (log.f64 (pow.f64 re #s(literal 4 binary64)))))
(- (+ (* 1/2 (log (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))) (* 1/2 (log (pow re 4))))
(*.f64 #s(literal 1/2 binary64) (-.f64 (+.f64 (log.f64 (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 im im) (*.f64 re re))) (log.f64 (pow.f64 re #s(literal 4 binary64)))))
(- (+ (* 1/2 (log (pow re 6))) (* (pow im 2) (+ (* -1/2 (/ (* im (+ re (* -1 re))) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (* 1/2 (log (pow re 4))))
(fma.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) (/.f64 #s(literal 0 binary64) (pow.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 re #s(literal 6 binary64))) (log.f64 (pow.f64 re #s(literal 4 binary64))))))
(- (+ (* 1/2 (log (pow re 6))) (* (pow im 2) (+ (* im (- (* -1/4 (/ im (pow re 4))) (* 1/2 (/ (+ re (* -1 re)) (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (* 1/2 (log (pow re 4))))
(fma.f64 (*.f64 (fma.f64 im (fma.f64 #s(literal -1/4 binary64) (/.f64 im (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) im) im (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 re #s(literal 6 binary64))) (log.f64 (pow.f64 re #s(literal 4 binary64))))))
(- (* -3 (log (/ 1 im))) (* -2 (log (/ 1 im))))
(log.f64 im)
(- (+ (* -3 (log (/ 1 im))) (* -1/2 (/ (+ re (* -1 re)) im))) (* -2 (log (/ 1 im))))
(+.f64 (/.f64 #s(literal 0 binary64) im) (log.f64 im))
(- (+ (* -3 (log (/ 1 im))) (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2)))) (+ (* -2 (log (/ 1 im))) (* 1/2 (/ (+ re (* -1 re)) im))))
(+.f64 (+.f64 (/.f64 (neg.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 re re) #s(literal 0 binary64))) (*.f64 im im)) (log.f64 im)) (/.f64 #s(literal 0 binary64) im))
(- (+ (* -3 (log (/ 1 im))) (* -1/12 (/ (+ (* 2 (pow (+ re (* -1 re)) 3)) (* 6 (* (pow re 2) (+ re (* -1 re))))) (pow im 3)))) (+ (* -2 (log (/ 1 im))) (+ (* 1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2))) (* 1/2 (/ (+ re (* -1 re)) im)))))
(-.f64 (+.f64 (/.f64 #s(literal 0 binary64) (*.f64 im (*.f64 im im))) (log.f64 im)) (+.f64 (/.f64 #s(literal 0 binary64) im) (/.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 re re) #s(literal 0 binary64)) (*.f64 im im))))
(- (* -3 (log (/ -1 im))) (* -2 (log (/ -1 im))))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(- (+ (* -3 (log (/ -1 im))) (* -1/2 (/ (+ re (* -1 re)) im))) (* -2 (log (/ -1 im))))
(+.f64 (/.f64 #s(literal 0 binary64) im) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(- (+ (* -3 (log (/ -1 im))) (* -1 (/ (- (* 1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) im)) (* -1/2 (+ re (* -1 re)))) im))) (* -2 (log (/ -1 im))))
(+.f64 (/.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 re re) #s(literal 0 binary64)) im) #s(literal 0 binary64)) (neg.f64 im)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(- (+ (* -3 (log (/ -1 im))) (* -1 (/ (- (* -1 (/ (- (* 1/12 (/ (+ (* -6 (* (pow re 2) (+ re (* -1 re)))) (* -2 (pow (+ re (* -1 re)) 3))) im)) (* 1/4 (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))))) im)) (* -1/2 (+ re (* -1 re)))) im))) (* -2 (log (/ -1 im))))
(+.f64 (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 #s(literal 0 binary64) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 re re) #s(literal 0 binary64))) (neg.f64 im)) #s(literal 0 binary64)) (neg.f64 im)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (- (* 1/2 (log (pow im 6))) (* 1/2 (log (pow im 4)))) (log 10))
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64)))
(- (+ (* -1/4 (/ (* (pow re 2) (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2))))) (log 10))) (* 1/2 (/ (log (pow im 6)) (log 10)))) (* 1/2 (/ (log (pow im 4)) (log 10))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64))))
(- (+ (* 1/2 (/ (log (pow im 6)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))) (log 10))) (* -1/12 (/ (* re (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4))))) (log 10)))))) (* 1/2 (/ (log (pow im 4)) (log 10))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 im im))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -1/12 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 6 binary64))))) re) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64))))
(- (+ (* 1/2 (/ (log (pow im 6)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))) (log 10))) (* re (+ (* -1/12 (/ (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))) (log 10))) (* -1/48 (/ (* re (+ (* -24 (/ (pow (+ im (* -1 im)) 2) (pow im 6))) (+ (* -6 (/ (pow (+ im (* -1 im)) 4) (pow im 8))) (* 12 (/ 1 (pow im 4)))))) (log 10)))))))) (* 1/2 (/ (log (pow im 4)) (log 10))))
(fma.f64 (*.f64 re re) (fma.f64 re (fma.f64 (*.f64 #s(literal -1/48 binary64) re) (/.f64 (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 8 binary64))) (+.f64 (/.f64 #s(literal 12 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 6 binary64))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal -1/12 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 6 binary64))))) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64))))
(/ (- (* -3 (log (/ 1 re))) (* -2 (log (/ 1 re)))) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(- (+ (* -3 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (* -2 (/ (log (/ 1 re)) (log 10))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(- (+ (* -3 (/ (log (/ 1 re)) (log 10))) (+ (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (* (pow re 3) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (* -2 (/ (log (/ 1 re)) (log 10))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re (*.f64 re re))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(- (+ (* -3 (/ (log (/ 1 re)) (log 10))) (+ (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (* (pow re 3) (log 10)))) (+ (* -1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (* -2 (/ (log (/ 1 re)) (log 10))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/48 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal 12 binary64)) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re (*.f64 re re)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(/ (- (* -3 (log (/ -1 re))) (* -2 (log (/ -1 re)))) (log 10))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(- (+ (* -3 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (* -2 (/ (log (/ -1 re)) (log 10))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(- (+ (* -3 (/ (log (/ -1 re)) (log 10))) (+ (* 1/2 (/ (* (pow im 2) (+ im (* -1 im))) (* (pow re 3) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (* -2 (/ (log (/ -1 re)) (log 10))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re (*.f64 re re))))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(- (+ (* -3 (/ (log (/ -1 re)) (log 10))) (+ (* -1 (/ (+ (* -1/2 (/ (* (pow im 2) (+ im (* -1 im))) (log 10))) (* 1/48 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (* re (log 10))))) (pow re 3))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (* -2 (/ (log (/ -1 re)) (log 10))))
(+.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (fma.f64 #s(literal 1/48 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal 12 binary64)) (*.f64 re (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 re (*.f64 re re)))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(/ (- (* 1/2 (log (pow re 6))) (* 1/2 (log (pow re 4)))) (log 10))
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 re #s(literal 6 binary64))) (log.f64 (pow.f64 re #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64)))
(- (+ (* 1/2 (/ (log (pow re 6)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (* 1/2 (/ (log (pow re 4)) (log 10))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 re #s(literal 6 binary64))) (log.f64 (pow.f64 re #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64))))
(- (+ (* 1/2 (/ (log (pow re 6)) (log 10))) (* (pow im 2) (+ (* -1/2 (/ (* im (+ re (* -1 re))) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (* 1/2 (/ (log (pow re 4)) (log 10))))
(fma.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 0 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 re #s(literal 6 binary64))) (log.f64 (pow.f64 re #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64))))
(- (+ (* 1/2 (/ (log (pow re 6)) (log 10))) (* (pow im 2) (+ (* im (+ (* -1/2 (/ (+ re (* -1 re)) (* (pow re 4) (log 10)))) (* -1/4 (/ im (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (* 1/2 (/ (log (pow re 4)) (log 10))))
(fma.f64 (*.f64 im im) (fma.f64 im (fma.f64 #s(literal -1/4 binary64) (/.f64 im (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 0 binary64) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (pow.f64 re #s(literal 6 binary64))) (log.f64 (pow.f64 re #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64))))
(/ (- (* -3 (log (/ 1 im))) (* -2 (log (/ 1 im)))) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(- (+ (* -3 (/ (log (/ 1 im)) (log 10))) (* -1/2 (/ (+ re (* -1 re)) (* im (log 10))))) (* -2 (/ (log (/ 1 im)) (log 10))))
(+.f64 (/.f64 #s(literal 0 binary64) (*.f64 im (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(- (+ (* -3 (/ (log (/ 1 im)) (log 10))) (+ (* -1/2 (/ (+ re (* -1 re)) (* im (log 10)))) (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (* (pow im 2) (log 10)))))) (* -2 (/ (log (/ 1 im)) (log 10))))
(+.f64 (+.f64 (/.f64 #s(literal 0 binary64) (*.f64 im (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 re re) #s(literal 0 binary64))) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(- (+ (* -3 (/ (log (/ 1 im)) (log 10))) (+ (* -1/2 (/ (+ re (* -1 re)) (* im (log 10)))) (+ (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (* (pow im 2) (log 10)))) (* -1/12 (/ (+ (* 2 (pow (+ re (* -1 re)) 3)) (* 6 (* (pow re 2) (+ re (* -1 re))))) (* (pow im 3) (log 10))))))) (* -2 (/ (log (/ 1 im)) (log 10))))
(+.f64 (+.f64 (/.f64 (neg.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 re re) #s(literal 0 binary64))) (*.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (+.f64 (/.f64 #s(literal 0 binary64) (*.f64 im (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im (*.f64 im im)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/ (- (* -3 (log (/ -1 im))) (* -2 (log (/ -1 im)))) (log 10))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(- (+ (* -3 (/ (log (/ -1 im)) (log 10))) (* -1/2 (/ (+ re (* -1 re)) (* im (log 10))))) (* -2 (/ (log (/ -1 im)) (log 10))))
(+.f64 (/.f64 #s(literal 0 binary64) (*.f64 im (log.f64 #s(literal 10 binary64)))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(- (+ (* -3 (/ (log (/ -1 im)) (log 10))) (* -1 (/ (+ (* 1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (* im (log 10)))) (* 1/2 (/ (+ re (* -1 re)) (log 10)))) im))) (* -2 (/ (log (/ -1 im)) (log 10))))
(+.f64 (/.f64 (+.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 re re) #s(literal 0 binary64)) (*.f64 im (log.f64 #s(literal 10 binary64))))) (neg.f64 im)) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(- (+ (* -3 (/ (log (/ -1 im)) (log 10))) (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (log 10))) (* 1/12 (/ (+ (* -6 (* (pow re 2) (+ re (* -1 re)))) (* -2 (pow (+ re (* -1 re)) 3))) (* im (log 10))))) im)) (* 1/2 (/ (+ re (* -1 re)) (log 10)))) im))) (* -2 (/ (log (/ -1 im)) (log 10))))
(+.f64 (/.f64 (-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (+.f64 (/.f64 #s(literal 0 binary64) (*.f64 im (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 re re) #s(literal 0 binary64))) (log.f64 #s(literal 10 binary64)))) im)) (neg.f64 im)) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(* 1/2 (log (pow im 6)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (pow.f64 im #s(literal 6 binary64))))
(+ (* 1/2 (log (pow im 6))) (* 1/2 (/ (pow re 6) (pow im 6))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 6 binary64)))))
(+ (* 1/2 (log (pow im 6))) (* (pow re 6) (+ (* -1/4 (/ (pow re 6) (pow im 12))) (* 1/2 (/ 1 (pow im 6))))))
(fma.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 12 binary64))) (/.f64 #s(literal 1/2 binary64) (pow.f64 im #s(literal 6 binary64)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (pow.f64 im #s(literal 6 binary64)))))
(+ (* 1/2 (log (pow im 6))) (* (pow re 6) (+ (* (pow re 6) (- (* 1/6 (/ (pow re 6) (pow im 18))) (* 1/4 (/ 1 (pow im 12))))) (* 1/2 (/ 1 (pow im 6))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 18 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 12 binary64)))) (/.f64 #s(literal 1/2 binary64) (pow.f64 im #s(literal 6 binary64))))))
(* -3 (log (/ 1 re)))
(neg.f64 (*.f64 (log.f64 re) #s(literal -3 binary64)))
(+ (* -3 (log (/ 1 re))) (* 1/2 (/ (pow im 6) (pow re 6))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (neg.f64 (*.f64 (log.f64 re) #s(literal -3 binary64))))
(+ (* -3 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (* 1/2 (/ (pow im 6) (pow re 6)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (neg.f64 (*.f64 (log.f64 re) #s(literal -3 binary64)))))
(+ (* -3 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (+ (* 1/6 (/ (pow im 18) (pow re 18))) (* 1/2 (/ (pow im 6) (pow re 6))))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -3 binary64) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 18 binary64))) (pow.f64 re #s(literal 18 binary64))))))
(* -3 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -3 binary64))
(+ (* -3 (log (/ -1 re))) (* 1/2 (/ (pow im 6) (pow re 6))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -3 binary64)))
(+ (* -3 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (* 1/2 (/ (pow im 6) (pow re 6)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -3 binary64))))
(+ (* -3 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 12) (pow re 12))) (+ (* 1/6 (/ (pow im 18) (pow re 18))) (* 1/2 (/ (pow im 6) (pow re 6))))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -3 binary64) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 18 binary64))) (pow.f64 re #s(literal 18 binary64))))))
(* 1/2 (log (pow re 6)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (pow.f64 re #s(literal 6 binary64))))
(+ (* 1/2 (log (pow re 6))) (* 1/2 (/ (pow im 6) (pow re 6))))
(*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (log.f64 (pow.f64 re #s(literal 6 binary64)))))
(+ (* 1/2 (log (pow re 6))) (* (pow im 6) (+ (* -1/4 (/ (pow im 6) (pow re 12))) (* 1/2 (/ 1 (pow re 6))))))
(fma.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 12 binary64))) (/.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal 6 binary64)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (pow.f64 re #s(literal 6 binary64)))))
(+ (* 1/2 (log (pow re 6))) (* (pow im 6) (+ (* (pow im 6) (- (* 1/6 (/ (pow im 6) (pow re 18))) (* 1/4 (/ 1 (pow re 12))))) (* 1/2 (/ 1 (pow re 6))))))
(fma.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 18 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 12 binary64)))) (/.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal 6 binary64)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (pow.f64 re #s(literal 6 binary64)))))
(* -3 (log (/ 1 im)))
(*.f64 #s(literal 3 binary64) (log.f64 im))
(+ (* -3 (log (/ 1 im))) (* 1/2 (/ (pow re 6) (pow im 6))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 #s(literal 3 binary64) (log.f64 im)))
(+ (* -3 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (* 1/2 (/ (pow re 6) (pow im 6)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (*.f64 #s(literal 3 binary64) (log.f64 im))))
(+ (* -3 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (+ (* 1/6 (/ (pow re 18) (pow im 18))) (* 1/2 (/ (pow re 6) (pow im 6))))))
(fma.f64 #s(literal 3 binary64) (log.f64 im) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 12 binary64))) (pow.f64 im #s(literal 12 binary64))))))
(* -3 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -3 binary64))
(+ (* -3 (log (/ -1 im))) (* 1/2 (/ (pow re 6) (pow im 6))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -3 binary64)))
(+ (* -3 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (* 1/2 (/ (pow re 6) (pow im 6)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -3 binary64))))
(+ (* -3 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 12) (pow im 12))) (+ (* 1/6 (/ (pow re 18) (pow im 18))) (* 1/2 (/ (pow re 6) (pow im 6))))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -3 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 18 binary64)) (pow.f64 im #s(literal 18 binary64))) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 12 binary64))) (pow.f64 im #s(literal 12 binary64))))))
(log (pow im 6))
(log.f64 (pow.f64 im #s(literal 6 binary64)))
(+ (log (pow im 6)) (/ (pow re 6) (pow im 6)))
(+.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (log.f64 (pow.f64 im #s(literal 6 binary64))))
(+ (log (pow im 6)) (* (pow re 6) (+ (* -1/2 (/ (pow re 6) (pow im 12))) (/ 1 (pow im 6)))))
(fma.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))) (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 (pow.f64 im #s(literal 6 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)))))
(fma.f64 (pow.f64 re #s(literal 6 binary64)) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (fma.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)))) (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 6 binary64)))) (log.f64 (pow.f64 im #s(literal 6 binary64))))
(* -6 (log (/ 1 re)))
(neg.f64 (*.f64 (log.f64 re) #s(literal -6 binary64)))
(+ (* -6 (log (/ 1 re))) (/ (pow im 6) (pow re 6)))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -6 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))
(+ (* -6 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -6 binary64) (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)))))
(+ (* -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)))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -6 binary64) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 im #s(literal 18 binary64)) (pow.f64 re #s(literal 18 binary64))) (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))))))
(* -6 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -6 binary64))
(+ (* -6 (log (/ -1 re))) (/ (pow im 6) (pow re 6)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -6 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))))
(+ (* -6 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 12) (pow re 12))) (/ (pow im 6) (pow re 6))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 12 binary64)) (pow.f64 re #s(literal 12 binary64))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -6 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 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)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -6 binary64) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 im #s(literal 18 binary64)) (pow.f64 re #s(literal 18 binary64))) (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))))))
(log (pow re 6))
(log.f64 (pow.f64 re #s(literal 6 binary64)))
(+ (log (pow re 6)) (/ (pow im 6) (pow re 6)))
(+.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (log.f64 (pow.f64 re #s(literal 6 binary64))))
(+ (log (pow re 6)) (* (pow im 6) (+ (* -1/2 (/ (pow im 6) (pow re 12))) (/ 1 (pow re 6)))))
(fma.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))) (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (pow.f64 re #s(literal 6 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)))))
(fma.f64 (pow.f64 im #s(literal 6 binary64)) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (fma.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)))) (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (pow.f64 re #s(literal 6 binary64))))
(* -6 (log (/ 1 im)))
(*.f64 #s(literal 6 binary64) (log.f64 im))
(+ (* -6 (log (/ 1 im))) (/ (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))))
(+ (* -6 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))
(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 6 binary64) (log.f64 im) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 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)))))
(fma.f64 #s(literal 6 binary64) (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))))))
(* -6 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -6 binary64))
(+ (* -6 (log (/ -1 im))) (/ (pow re 6) (pow im 6)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))
(+ (* -6 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 12) (pow im 12))) (/ (pow re 6) (pow im 6))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 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)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -6 binary64) (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))))))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(* -2 (log (/ 1 re)))
(neg.f64 (*.f64 #s(literal -2 binary64) (log.f64 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 im im) (*.f64 re re))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
(* -2 (log (/ -1 re)))
(*.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (*.f64 im im) (*.f64 re re))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(* -2 (log (/ 1 im)))
(*.f64 #s(literal 2 binary64) (log.f64 im))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (/.f64 (*.f64 re re) (*.f64 im im)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 2 binary64) (log.f64 im) (/.f64 (*.f64 re re) (*.f64 im im))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
(* -2 (log (/ -1 im)))
(*.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 re re) (*.f64 im im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (/.f64 (*.f64 re re) (*.f64 im im))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))))
(log (pow im 4))
(log.f64 (pow.f64 im #s(literal 4 binary64)))
(+ (log (pow im 4)) (* 1/2 (* (pow re 2) (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2)))))))
(fma.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 im im))) (log.f64 (pow.f64 im #s(literal 4 binary64))))
(+ (log (pow im 4)) (* (pow re 2) (+ (* 1/6 (* re (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4)))))) (* 1/2 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2))))))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 im im))) (*.f64 (*.f64 #s(literal 1/6 binary64) re) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 6 binary64)))))) (log.f64 (pow.f64 im #s(literal 4 binary64))))
(+ (log (pow im 4)) (* (pow re 2) (+ (* 1/2 (- (* -1 (/ (pow (+ im (* -1 im)) 2) (pow im 4))) (* 2 (/ 1 (pow im 2))))) (* re (+ (* 1/24 (* re (+ (* -24 (/ (pow (+ im (* -1 im)) 2) (pow im 6))) (+ (* -6 (/ (pow (+ im (* -1 im)) 4) (pow im 8))) (* 12 (/ 1 (pow im 4))))))) (* 1/6 (+ (* 2 (/ (pow (+ im (* -1 im)) 3) (pow im 6))) (* 6 (/ (+ im (* -1 im)) (pow im 4))))))))))
(fma.f64 (*.f64 re re) (fma.f64 re (fma.f64 #s(literal 1/24 binary64) (*.f64 re (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 8 binary64))) (+.f64 (/.f64 #s(literal 12 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 6 binary64)))))) (*.f64 #s(literal 1/6 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 6 binary64)))))) (*.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 im im))))) (log.f64 (pow.f64 im #s(literal 4 binary64))))
(* -4 (log (/ 1 re)))
(neg.f64 (*.f64 (log.f64 re) #s(literal -4 binary64)))
(+ (* -4 (log (/ 1 re))) (* -1 (/ (pow im 2) (pow re 2))))
(-.f64 (neg.f64 (*.f64 (log.f64 re) #s(literal -4 binary64))) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -4 binary64) (-.f64 (/.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re))) (/.f64 (*.f64 im im) (*.f64 re re))))
(+ (* -4 (log (/ 1 re))) (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (* 1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) (pow re 4))) (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3)))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -4 binary64) (-.f64 (fma.f64 #s(literal 1/24 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal 12 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 im im) (*.f64 re re))))
(* -4 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -4 binary64))
(+ (* -4 (log (/ -1 re))) (* -1 (/ (pow im 2) (pow re 2))))
(-.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -4 binary64)) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (* (pow im 2) (+ im (* -1 im))) (pow re 3))) (* -1 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -4 binary64) (/.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -4 (log (/ -1 re))) (+ (* -1 (/ (+ (* -1/24 (/ (+ (* -12 (pow im 4)) (* 24 (pow im 4))) re)) (* (pow im 2) (+ im (* -1 im)))) (pow re 3))) (* -1 (/ (pow im 2) (pow re 2)))))
(-.f64 (-.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -4 binary64)) (/.f64 (fma.f64 #s(literal -1/24 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal 12 binary64)) re) #s(literal 0 binary64)) (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 im im) (*.f64 re re)))
(log (pow re 4))
(log.f64 (pow.f64 re #s(literal 4 binary64)))
(+ (log (pow re 4)) (* -1 (/ (pow im 2) (pow re 2))))
(-.f64 (log.f64 (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (log (pow re 4)) (* (pow im 2) (- (/ (* im (+ re (* -1 re))) (pow re 4)) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 0 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1 binary64) (*.f64 re re))) (log.f64 (pow.f64 re #s(literal 4 binary64))))
(+ (log (pow re 4)) (* (pow im 2) (- (* im (+ (* 1/2 (/ im (pow re 4))) (+ (/ -1 (pow re 3)) (/ 1 (pow re 3))))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 im (+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 im (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal -1 binary64) (*.f64 re re))) (log.f64 (pow.f64 re #s(literal 4 binary64))))
(* -4 (log (/ 1 im)))
(*.f64 #s(literal 4 binary64) (log.f64 im))
(+ (* -4 (log (/ 1 im))) (+ (* -1 (/ re im)) (/ re im)))
(fma.f64 #s(literal 4 binary64) (log.f64 im) #s(literal 0 binary64))
(+ (* -4 (log (/ 1 im))) (+ (* -1 (/ re im)) (+ (* 1/2 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2))) (/ re im))))
(+.f64 (fma.f64 #s(literal 4 binary64) (log.f64 im) #s(literal 0 binary64)) (/.f64 (fma.f64 (neg.f64 re) re #s(literal 0 binary64)) (*.f64 im im)))
(+ (* -4 (log (/ 1 im))) (+ (* -1 (/ re im)) (+ (* 1/6 (/ (+ (* 2 (pow (+ re (* -1 re)) 3)) (* 6 (* (pow re 2) (+ re (* -1 re))))) (pow im 3))) (+ (* 1/2 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) (pow im 2))) (/ re im)))))
(+.f64 (+.f64 (fma.f64 #s(literal 4 binary64) (log.f64 im) #s(literal 0 binary64)) (/.f64 (fma.f64 (neg.f64 re) re #s(literal 0 binary64)) (*.f64 im im))) (/.f64 #s(literal 0 binary64) (*.f64 im (*.f64 im im))))
(* -4 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -4 binary64))
(+ (* -4 (log (/ -1 im))) (+ (* -1 (/ re im)) (/ re im)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -4 binary64) #s(literal 0 binary64))
(+ (* -4 (log (/ -1 im))) (* -1 (/ (+ (* -1 (+ re (* -1 re))) (* -1/2 (/ (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))) im))) im)))
(-.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -4 binary64)) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (fma.f64 (*.f64 re re) #s(literal -2 binary64) #s(literal 0 binary64)) im) #s(literal 0 binary64)) im))
(+ (* -4 (log (/ -1 im))) (* -1 (/ (+ (* -1 (+ re (* -1 re))) (* -1 (/ (+ (* -1/6 (/ (+ (* -6 (* (pow re 2) (+ re (* -1 re)))) (* -2 (pow (+ re (* -1 re)) 3))) im)) (* 1/2 (+ (* -2 (pow re 2)) (* -1 (pow (+ re (* -1 re)) 2))))) im))) im)))
(-.f64 (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -4 binary64)) (/.f64 (/.f64 (+.f64 (/.f64 #s(literal 0 binary64) im) (fma.f64 (neg.f64 re) re #s(literal 0 binary64))) (neg.f64 im)) im))

eval396.0ms (1.5%)

Memory
-1.7MiB live, 339.6MiB allocated
Compiler

Compiled 74 574 to 3 448 computations (95.4% saved)

prune348.0ms (1.4%)

Memory
-7.7MiB live, 322.4MiB allocated
Pruning

21 alts after pruning (16 fresh and 5 done)

PrunedKeptTotal
New1 48541 489
Fresh11213
Picked235
Done022
Total1 488211 509
Accuracy
100.0%
Counts
1 509 → 21
Alt Table
Click to see full alt table
StatusAccuracyProgram
72.9%
(pow.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
▶30.4%
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
98.1%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
▶98.4%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
22.8%
(/.f64 (-.f64 (*.f64 #s(literal 3 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
47.6%
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))))
▶98.4%
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
98.3%
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
47.5%
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
✓47.6%
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓98.4%
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓98.8%
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓98.8%
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
✓98.5%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
▶98.4%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
47.5%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
98.4%
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
▶98.0%
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
47.4%
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
30.7%
(sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
72.5%
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
Compiler

Compiled 608 to 416 computations (31.6% saved)

simplify257.0ms (1%)

Memory
-1.1MiB live, 194.3MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
✓cost-diff64
(-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓cost-diff13824
(*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
✓cost-diff13824
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
✓cost-diff0
(log.f64 (fma.f64 re re (*.f64 im im)))
✓cost-diff0
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
✓cost-diff0
(sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
✓cost-diff7104
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
✓cost-diff0
(log.f64 #s(literal 1/10 binary64))
✓cost-diff0
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓cost-diff128
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓cost-diff1280
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
✓cost-diff320
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(log.f64 #s(literal 10 binary64))
✓cost-diff0
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓cost-diff704
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
Rules
3 396×lower-*.f32
3 388×lower-*.f64
2 574×lower-/.f32
2 556×lower-/.f64
2 370×lower-neg.f32
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
030189
054168
191155
2150151
3298151
4510151
51232151
62094151
72666151
83506151
97666151
08138151
Stop Event
1×iter limit
1×node limit
1×iter limit
Calls
Call 1
Inputs
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
#s(literal 1 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal 1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(log.f64 im)
im
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal 2 binary64)
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
#s(literal 0 binary64)
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(log.f64 im)
im
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
Outputs
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
#s(literal 1 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal 1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(log.f64 im)
im
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
re
(*.f64 im im)
im
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal 2 binary64)
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
#s(literal 0 binary64)
#s(literal 0 binary64)
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(log.f64 im)
im
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))

localize277.0ms (1.1%)

Memory
5.5MiB live, 196.4MiB allocated
Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
✓accuracy99.3%
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
✓accuracy99.3%
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
✓accuracy99.3%
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
✓accuracy98.8%
(log.f64 #s(literal 1/10 binary64))
✓accuracy99.8%
(sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
✓accuracy99.4%
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
✓accuracy99.3%
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
✓accuracy56.9%
(log.f64 (fma.f64 re re (*.f64 im im)))
✓accuracy99.7%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
✓accuracy99.7%
(/.f64 #s(literal 1 binary64) (log.f64 im))
✓accuracy98.8%
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓accuracy98.8%
(log.f64 #s(literal 1/10 binary64))
✓accuracy100.0%
(log.f64 im)
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.7%
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
✓accuracy98.8%
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
✓accuracy100.0%
(log.f64 im)
✓accuracy100.0%
(log.f64 #s(literal 10 binary64))
✓accuracy99.7%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
✓accuracy99.3%
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
Samples
122.0ms189×0valid
18.0ms67×0invalid
Compiler

Compiled 196 to 33 computations (83.2% saved)

Precisions
Click to see histograms. Total time spent on operations: 87.0ms
ival-sqrt: 43.0ms (49.4% of total)
ival-div: 14.0ms (16.1% of total)
ival-log: 12.0ms (13.8% of total)
ival-mult: 8.0ms (9.2% of total)
const: 4.0ms (4.6% of total)
ival-pow2: 2.0ms (2.3% of total)
ival-add: 1.0ms (1.1% of total)
ival-sub: 1.0ms (1.1% of total)
exact: 1.0ms (1.1% of total)
ival-neg: 1.0ms (1.1% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

series177.0ms (0.7%)

Memory
-14.9MiB live, 100.8MiB allocated
Counts
20 → 240
Calls
Call 1
Inputs
#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation binary64>) () ())
#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())
#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())
#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 1/10 binary64)) (patch (log.f64 #s(literal 1/10 binary64)) #<representation binary64>) () ())
#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())
#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())
#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())
#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())
#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())
Outputs
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)) (taylor -inf im) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) (patch (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) (patch (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log im)) (taylor 0 im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log im)) (taylor 0 im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log im)) (taylor 0 im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log im)) (taylor 0 im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 im))) (taylor inf im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 im))) (taylor inf im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 im))) (taylor inf im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 im))) (taylor inf im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) (patch (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (taylor 0 re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))) (taylor 0 re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/2 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))) (taylor 0 re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow im 4) (log 10)))) (* 1/3 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))) (taylor 0 re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (taylor inf re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))) (taylor inf re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (taylor -inf re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))) (taylor -inf re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (taylor 0 im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))) (taylor 0 im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/2 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))) (taylor 0 im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow re 4) (log 10)))) (* 1/3 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))) (taylor 0 im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (taylor inf im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))) (taylor inf im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (taylor -inf im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))) (taylor -inf im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) (patch (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (taylor 0 re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (pow im 2)) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2))) (taylor 0 re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* -1/2 (* (* (pow re 2) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow im 4) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (log 10) (log (pow im 2))))))))) (sqrt (/ (log 10) (log (pow im 2)))))) (* 1/2 (* (/ (sqrt 1/2) (pow im 2)) (sqrt (/ 1 (* (log 10) (log (pow im 2)))))))))) (taylor 0 re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* 1/2 (* (/ (sqrt 1/2) (pow im 2)) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow im 2)))) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow im 4) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (log 10) (log (pow im 2)))))))))) (* 1/2 (* (* (pow re 2) (* (sqrt 1/2) (- (* 1/3 (/ 1 (* (pow im 6) (log 10)))) (* -1/2 (/ (+ (* 1/2 (/ 1 (* (pow im 4) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (log 10) (log (pow im 2))))))) (* (pow im 2) (log (pow im 2)))))))) (sqrt (/ (log 10) (log (pow im 2))))))))))) (taylor 0 re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))) (taylor inf re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))) (taylor inf re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))) (taylor inf re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow im 6) (log 10))) (* 1/2 (/ (* (pow im 2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -2) 2))))))) (* (log (/ 1 re)) (pow (sqrt -2) 2)))))) (* (pow re 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))) (taylor inf re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))) (taylor -inf re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))) (taylor -inf re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))) (taylor -inf re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow im 6) (log 10))) (* 1/2 (/ (* (pow im 2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -2) 2))))))) (* (log (/ -1 re)) (pow (sqrt -2) 2)))))) (* (pow re 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (taylor 0 im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (pow re 2)) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2))) (taylor 0 im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow re 4) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (* (log 10) (log (pow re 2))))))))) (sqrt (/ (log 10) (log (pow re 2)))))) (* 1/2 (* (/ (sqrt 1/2) (pow re 2)) (sqrt (/ 1 (* (log 10) (log (pow re 2)))))))))) (taylor 0 im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* 1/2 (* (/ (sqrt 1/2) (pow re 2)) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow re 2)))) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow re 4) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (* (log 10) (log (pow re 2)))))))))) (* 1/2 (* (* (pow im 2) (* (sqrt 1/2) (- (* 1/3 (/ 1 (* (pow re 6) (log 10)))) (* -1/2 (/ (+ (* 1/2 (/ 1 (* (pow re 4) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (* (log 10) (log (pow re 2))))))) (* (pow re 2) (log (pow re 2)))))))) (sqrt (/ (log 10) (log (pow re 2))))))))))) (taylor 0 im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))) (taylor inf im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))) (taylor inf im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))) (taylor inf im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow re 6) (log 10))) (* 1/2 (/ (* (pow re 2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -2) 2))))))) (* (log (/ 1 im)) (pow (sqrt -2) 2)))))) (* (pow im 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))) (taylor inf im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))) (taylor -inf im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))) (taylor -inf im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))) (taylor -inf im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow re 6) (log 10))) (* 1/2 (/ (* (pow re 2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -2) 2))))))) (* (log (/ -1 im)) (pow (sqrt -2) 2)))))) (* (pow im 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (patch (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow im 2)) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow re 2)) (log 10))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (patch (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (pow im 2)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (log (pow re 2)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (*.f64 im im))) (patch (log.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (patch (/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf im) (#s(alt (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor 0 im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor 0 im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor 0 im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor 0 im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor inf im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor inf im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor inf im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor inf im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor -inf im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor -inf im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor -inf im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log 1/10)) (taylor -inf im) (#s(alt (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log im)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 1/10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 1/10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 1/10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 1/10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log im)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log im)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log im)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log im)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ 1 im))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ 1 im))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ 1 im))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ 1 im))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (log.f64 im)) (patch (/.f64 #s(literal 1 binary64) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 1/10) 2) (log im)) (taylor 0 im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 1/10) 2) (log im)) (taylor 0 im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 1/10) 2) (log im)) (taylor 0 im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 1/10) 2) (log im)) (taylor 0 im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (pow (log 1/10) 2) (log (/ 1 im)))) (taylor inf im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (pow (log 1/10) 2) (log (/ 1 im)))) (taylor inf im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (pow (log 1/10) 2) (log (/ 1 im)))) (taylor inf im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (pow (log 1/10) 2) (log (/ 1 im)))) (taylor inf im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (patch (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) #<representation binary64>) () ())) ())
Calls

60 calls:

TimeVariablePointExpression
86.0ms
re
@inf
(sqrt (/ (log (+ (* re re) (* im im))) (* (log 10) 2)))
68.0ms
im
@inf
(sqrt (/ (log (+ (* re re) (* im im))) (* (log 10) 2)))
1.0ms
im
@0
(sqrt (/ (log (+ (* re re) (* im im))) (* (log 10) 2)))
1.0ms
re
@0
(sqrt (/ (log (+ (* re re) (* im im))) (* (log 10) 2)))
1.0ms
im
@-inf
(sqrt (/ (log (+ (* re re) (* im im))) (* (log 10) 2)))

rewrite129.0ms (0.5%)

Memory
5.7MiB live, 80.6MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
482×lower-/.f32
464×lower-/.f64
432×lower-*.f32
424×lower-*.f64
124×lower-fma.f32
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
030148
054125
1182111
0994111
Stop Event
1×iter limit
1×iter limit
1×node limit
1×iter limit
Counts
20 → 366
Calls
Call 1
Inputs
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log.f64 #s(literal 10 binary64))
(log.f64 im)
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 1/10 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
Outputs
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 im) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (neg.f64 (log.f64 im)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (log.f64 im))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (neg.f64 (log.f64 im))))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(/.f64 (*.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(*.f64 #s(literal -1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(literal 10 binary64))
(+.f64 (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(fma.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 im)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (log.f64 im) #s(literal 1 binary64))
(/.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 (log.f64 im) #s(literal 1 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 im) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (neg.f64 (log.f64 im)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (log.f64 im))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 im) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 im) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (neg.f64 (log.f64 im)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)) (log.f64 im))
(+.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) #s(literal -1 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/.f64 #s(literal -1 binary64) (neg.f64 (neg.f64 (log.f64 im))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 im)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 im)))) (+.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(pow.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(neg.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1/2 binary64)))
(log.f64 #s(literal 1/10 binary64))
(+.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(exp.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1 binary64)))
(sqrt.f64 (*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(neg.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))
(neg.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(/.f64 (*.f64 (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))
(/.f64 (neg.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64)))) #s(literal -2 binary64))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1/2 binary64))
(pow.f64 (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) #s(literal 2 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 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 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1/2 binary64)))
(sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 (sqrt.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))
(/.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal 2 binary64)))
(/.f64 (neg.f64 (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1 binary64))
(*.f64 (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1/2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1 binary64)))
(sqrt.f64 (*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(neg.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))
(neg.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
(/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(/.f64 (*.f64 (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))
(/.f64 (neg.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64)))) #s(literal -2 binary64))
(/.f64 (*.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (sqrt.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))) (sqrt.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 1/2 binary64))
(pow.f64 (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) #s(literal 2 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 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 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))
(*.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))) (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))))))
(log.f64 (fma.f64 im im (*.f64 re re)))
(-.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re))))))
(-.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(+.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)))
(-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)))
(neg.f64 (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))) (*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))))
(/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)) (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)) (*.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)) (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)))) (+.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im))))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(pow.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)))
(*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)))))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 im))
(*.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 im)))
#s(literal 0 binary64)
(log.f64 #s(literal 10 binary64))
(+.f64 (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(fma.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 0 binary64))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (neg.f64 (log.f64 im))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(neg.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (log.f64 im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(pow.f64 (log.f64 im) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (neg.f64 (log.f64 im)))
(/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(/.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 im)))
(/.f64 (*.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))

simplify528.0ms (2.1%)

Memory
6.7MiB live, 515.1MiB allocated
Algorithm
1×egg-herbie
Rules
7 096×lower-*.f64
7 096×lower-*.f32
6 850×lower-fma.f64
6 850×lower-fma.f32
2 882×lower-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
05234886
115354174
260144126
085393976
Stop Event
1×iter limit
1×node limit
Counts
240 → 240
Calls
Call 1
Inputs
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (log 10) (log im))
(/ (log 10) (log im))
(/ (log 10) (log im))
(/ (log 10) (log im))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/ -1 (log im))
(/ -1 (log im))
(/ -1 (log im))
(/ -1 (log im))
(/ 1 (log (/ 1 im)))
(/ 1 (log (/ 1 im)))
(/ 1 (log (/ 1 im)))
(/ 1 (log (/ 1 im)))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))
(+ (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(+ (* (pow re 2) (+ (* -1/2 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow im 4) (log 10)))) (* 1/3 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))
(+ (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(+ (* (pow im 2) (+ (* -1/2 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow re 4) (log 10)))) (* 1/3 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2))
(+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (pow im 2)) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* -1/2 (* (* (pow re 2) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow im 4) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (log 10) (log (pow im 2))))))))) (sqrt (/ (log 10) (log (pow im 2)))))) (* 1/2 (* (/ (sqrt 1/2) (pow im 2)) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))))))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* 1/2 (* (/ (sqrt 1/2) (pow im 2)) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow im 2)))) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow im 4) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (log 10) (log (pow im 2)))))))))) (* 1/2 (* (* (pow re 2) (* (sqrt 1/2) (- (* 1/3 (/ 1 (* (pow im 6) (log 10)))) (* -1/2 (/ (+ (* 1/2 (/ 1 (* (pow im 4) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (log 10) (log (pow im 2))))))) (* (pow im 2) (log (pow im 2)))))))) (sqrt (/ (log 10) (log (pow im 2)))))))))))
(* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))
(+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow im 6) (log 10))) (* 1/2 (/ (* (pow im 2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -2) 2))))))) (* (log (/ 1 re)) (pow (sqrt -2) 2)))))) (* (pow re 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))))
(* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))
(+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow im 6) (log 10))) (* 1/2 (/ (* (pow im 2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -2) 2))))))) (* (log (/ -1 re)) (pow (sqrt -2) 2)))))) (* (pow re 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))))
(* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2))
(+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (pow re 2)) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow re 4) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (* (log 10) (log (pow re 2))))))))) (sqrt (/ (log 10) (log (pow re 2)))))) (* 1/2 (* (/ (sqrt 1/2) (pow re 2)) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))))))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* 1/2 (* (/ (sqrt 1/2) (pow re 2)) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow re 2)))) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow re 4) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (* (log 10) (log (pow re 2)))))))))) (* 1/2 (* (* (pow im 2) (* (sqrt 1/2) (- (* 1/3 (/ 1 (* (pow re 6) (log 10)))) (* -1/2 (/ (+ (* 1/2 (/ 1 (* (pow re 4) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (* (log 10) (log (pow re 2))))))) (* (pow re 2) (log (pow re 2)))))))) (sqrt (/ (log 10) (log (pow re 2)))))))))))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))
(+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow re 6) (log 10))) (* 1/2 (/ (* (pow re 2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -2) 2))))))) (* (log (/ 1 im)) (pow (sqrt -2) 2)))))) (* (pow im 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))))
(* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))
(+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow re 6) (log 10))) (* 1/2 (/ (* (pow re 2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -2) 2))))))) (* (log (/ -1 im)) (pow (sqrt -2) 2)))))) (* (pow im 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
0
0
0
0
0
0
0
0
0
0
0
0
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(* -1 (log 1/10))
(/ (log 1/10) (log im))
(/ (log 1/10) (log im))
(/ (log 1/10) (log im))
(/ (log 1/10) (log im))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (log im))
(/ 1 (log im))
(/ 1 (log im))
(/ 1 (log im))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (pow (log 1/10) 2) (log im))
(/ (pow (log 1/10) 2) (log im))
(/ (pow (log 1/10) 2) (log im))
(/ (pow (log 1/10) 2) (log im))
(* -1 (/ (pow (log 1/10) 2) (log (/ 1 im))))
(* -1 (/ (pow (log 1/10) 2) (log (/ 1 im))))
(* -1 (/ (pow (log 1/10) 2) (log (/ 1 im))))
(* -1 (/ (pow (log 1/10) 2) (log (/ 1 im))))
(/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im)))))
Outputs
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(neg.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(neg.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(neg.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(neg.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(/ -1 (log im))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ -1 (log im))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ -1 (log im))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ -1 (log im))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ 1 (log (/ 1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ 1 (log (/ 1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ 1 (log (/ 1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ 1 (log (/ 1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))
(*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(+ (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 re (/.f64 re (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* (pow re 2) (+ (* -1/2 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 re (/.f64 re (*.f64 im im)) (log.f64 (*.f64 im im)))))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow im 4) (log 10)))) (* 1/3 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (fma.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 re (/.f64 re (*.f64 im im)) (log.f64 (*.f64 im im)))))
(* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
(* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(-.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal 1/2 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))
(+ (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 im (/.f64 im (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* (pow im 2) (+ (* -1/2 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 im (/.f64 im (*.f64 re re)) (log.f64 (*.f64 re re)))))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow re 4) (log 10)))) (* 1/3 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 im (/.f64 im (*.f64 re re)) (log.f64 (*.f64 re re)))))
(* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))))
(* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (pow im 2)) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im)))))) (*.f64 im im)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* -1/2 (* (* (pow re 2) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow im 4) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (log 10) (log (pow im 2))))))))) (sqrt (/ (log 10) (log (pow im 2)))))) (* 1/2 (* (/ (sqrt 1/2) (pow im 2)) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))))) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im im))))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* 1/2 (* (/ (sqrt 1/2) (pow im 2)) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow im 2)))) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow im 4) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (log 10) (log (pow im 2)))))))))) (* 1/2 (* (* (pow re 2) (* (sqrt 1/2) (- (* 1/3 (/ 1 (* (pow im 6) (log 10)))) (* -1/2 (/ (+ (* 1/2 (/ 1 (* (pow im 4) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (* (log 10) (log (pow im 2))))))) (* (pow im 2) (log (pow im 2)))))))) (sqrt (/ (log 10) (log (pow im 2)))))))))))
(fma.f64 re (*.f64 re (fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 re re)) (*.f64 (-.f64 (/.f64 #s(literal 1/3 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (*.f64 im im) (log.f64 (*.f64 im im))))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im)))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (log.f64 (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 im im))))) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im im)))))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))
(*.f64 (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))
(fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -2 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))))) (*.f64 re (*.f64 re (sqrt.f64 #s(literal -2 binary64))))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))
(fma.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -2 binary64) (log.f64 re))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (sqrt.f64 #s(literal -2 binary64)))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (/.f64 (*.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))))) (*.f64 re (*.f64 re (sqrt.f64 #s(literal -2 binary64)))))) (*.f64 (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64)))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow im 6) (log 10))) (* 1/2 (/ (* (pow im 2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -2) 2))))))) (* (log (/ 1 re)) (pow (sqrt -2) 2)))))) (* (pow re 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -2 binary64) (log.f64 re))))) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (sqrt.f64 #s(literal -2 binary64))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (fma.f64 #s(literal 1/4 binary64) (*.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -2 binary64) (log.f64 re))))) (neg.f64 (/.f64 (*.f64 im im) (log.f64 re)))) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64)))))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (sqrt.f64 #s(literal -2 binary64))))) (fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -2 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))))) (*.f64 re (*.f64 re (sqrt.f64 #s(literal -2 binary64)))))))
(* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 re (*.f64 re (sqrt.f64 #s(literal -2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))
(fma.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/4 binary64)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (sqrt.f64 #s(literal -2 binary64)))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 re (*.f64 re (sqrt.f64 #s(literal -2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -2) 2))))))) (* (pow re 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow im 6) (log 10))) (* 1/2 (/ (* (pow im 2) (- (* -1/2 (/ (pow im 4) (log 10))) (* 1/4 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -2) 2))))))) (* (log (/ -1 re)) (pow (sqrt -2) 2)))))) (* (pow re 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (* (pow re 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (* (sqrt -2) (sqrt 1/2))))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/4 binary64)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (sqrt.f64 #s(literal -2 binary64))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/4 binary64)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))))) (log.f64 (/.f64 #s(literal -1 binary64) re))))))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (sqrt.f64 #s(literal -2 binary64))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 re (*.f64 re (sqrt.f64 #s(literal -2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))))
(* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (* (/ (* (pow im 2) (sqrt 1/2)) (pow re 2)) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)))
(fma.f64 (*.f64 im im) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 re re))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow re 4) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (* (log 10) (log (pow re 2))))))))) (sqrt (/ (log 10) (log (pow re 2)))))) (* 1/2 (* (/ (sqrt 1/2) (pow re 2)) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))))))
(fma.f64 (*.f64 im im) (fma.f64 im (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 (*.f64 re re))))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 re re)))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* 1/2 (* (/ (sqrt 1/2) (pow re 2)) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow re 2)))) (* (sqrt 1/2) (+ (* 1/2 (/ 1 (* (pow re 4) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (* (log 10) (log (pow re 2)))))))))) (* 1/2 (* (* (pow im 2) (* (sqrt 1/2) (- (* 1/3 (/ 1 (* (pow re 6) (log 10)))) (* -1/2 (/ (+ (* 1/2 (/ 1 (* (pow re 4) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (* (log 10) (log (pow re 2))))))) (* (pow re 2) (log (pow re 2)))))))) (sqrt (/ (log 10) (log (pow re 2)))))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 (*.f64 re re)))))) (*.f64 (*.f64 re re) (log.f64 (*.f64 re re)))) (/.f64 #s(literal 1/3 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64))))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re)))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))))) (fma.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 (*.f64 re re))))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (*.f64 re re))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 re re)))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 re re)) (*.f64 im (*.f64 im (sqrt.f64 #s(literal -2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 10 binary64))))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))
(fma.f64 #s(literal 1/2 binary64) (fma.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (log.f64 im) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))))) (/.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (sqrt.f64 #s(literal -2 binary64)))) (*.f64 (/.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 re re)) (*.f64 im (*.f64 im (sqrt.f64 #s(literal -2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 10 binary64)))))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow re 6) (log 10))) (* 1/2 (/ (* (pow re 2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -2) 2))))))) (* (log (/ 1 im)) (pow (sqrt -2) 2)))))) (* (pow im 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (log.f64 im) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (sqrt.f64 #s(literal -2 binary64))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (fma.f64 #s(literal 1/3 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (log.f64 im) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))))) (log.f64 im)))))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (sqrt.f64 #s(literal -2 binary64))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 re re)) (*.f64 im (*.f64 im (sqrt.f64 #s(literal -2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 10 binary64))))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 10 binary64))))))))
(* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im (*.f64 im (sqrt.f64 #s(literal -2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2)))))
(fma.f64 #s(literal 1/2 binary64) (fma.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/4 binary64)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))))) (/.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (sqrt.f64 #s(literal -2 binary64)))) (*.f64 (*.f64 re re) (*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im (*.f64 im (sqrt.f64 #s(literal -2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -2) 2))))))) (* (pow im 4) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (* (sqrt 1/2) (- (* 1/3 (/ (pow re 6) (log 10))) (* 1/2 (/ (* (pow re 2) (- (* -1/2 (/ (pow re 4) (log 10))) (* 1/4 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -2) 2))))))) (* (log (/ -1 im)) (pow (sqrt -2) 2)))))) (* (pow im 6) (sqrt -2))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (* (pow re 2) (sqrt 1/2)) (* (pow im 2) (sqrt -2))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (* (sqrt -2) (sqrt 1/2))))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/4 binary64)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (sqrt.f64 #s(literal -2 binary64))))) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 re re) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/4 binary64)) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64)))))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (sqrt.f64 #s(literal -2 binary64))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re re) (*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im (*.f64 im (sqrt.f64 #s(literal -2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(*.f64 (log.f64 (*.f64 im im)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 re (/.f64 re (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal -1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 re (/.f64 re (*.f64 im im)) (log.f64 (*.f64 im im)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (fma.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 re (/.f64 re (*.f64 im im)) (log.f64 (*.f64 im im)))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal 1/2 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 im (/.f64 im (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re)))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 im (/.f64 im (*.f64 re re)) (log.f64 (*.f64 re re)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 #s(literal 1/6 binary64) (/.f64 (*.f64 im im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))))) (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 im (/.f64 im (*.f64 re re)) (log.f64 (*.f64 re re)))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal -1/4 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 #s(literal -1/4 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/6 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(fma.f64 re (/.f64 re (*.f64 im im)) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/3 binary64) (/.f64 (*.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(* -2 (log (/ 1 re)))
(*.f64 #s(literal 2 binary64) (log.f64 re))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 im (/.f64 im (*.f64 re re)) (*.f64 #s(literal 2 binary64) (log.f64 re)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 im (/.f64 im (*.f64 re re)) (*.f64 #s(literal 2 binary64) (log.f64 re))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 re) (fma.f64 im (/.f64 im (*.f64 re re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(* -2 (log (/ -1 re)))
(*.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (*.f64 im im) (*.f64 re re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 im (/.f64 im (*.f64 re re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal -2 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 im (/.f64 im (*.f64 re re)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(fma.f64 im (/.f64 im (*.f64 re re)) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/3 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(* -2 (log (/ 1 im)))
(*.f64 (log.f64 im) #s(literal 2 binary64))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 im) #s(literal 2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (log.f64 im) #s(literal 2 binary64) (/.f64 (*.f64 re re) (*.f64 im im))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (log.f64 im) #s(literal 2 binary64) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 re (/.f64 re (*.f64 im im)) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))))
(* -2 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 re re) (*.f64 im im))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 re (/.f64 re (*.f64 im im)) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(neg.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(neg.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(neg.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(neg.f64 (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(* -1 (log 1/10))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/ (log 1/10) (log im))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(/ (log 1/10) (log im))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(/ (log 1/10) (log im))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(/ (log 1/10) (log im))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (pow (log 1/10) 2) (log im))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(/ (pow (log 1/10) 2) (log im))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(/ (pow (log 1/10) 2) (log im))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(/ (pow (log 1/10) 2) (log im))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(* -1 (/ (pow (log 1/10) 2) (log (/ 1 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(* -1 (/ (pow (log 1/10) 2) (log (/ 1 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(* -1 (/ (pow (log 1/10) 2) (log (/ 1 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(* -1 (/ (pow (log 1/10) 2) (log (/ 1 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (pow (log 1/10) 2) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))

eval130.0ms (0.5%)

Memory
-18.9MiB live, 147.3MiB allocated
Compiler

Compiled 14 812 to 1 672 computations (88.7% saved)

prune149.0ms (0.6%)

Memory
12.3MiB live, 173.4MiB allocated
Pruning

21 alts after pruning (14 fresh and 7 done)

PrunedKeptTotal
New8206826
Fresh3811
Picked325
Done055
Total82621847
Accuracy
100.0%
Counts
847 → 21
Alt Table
Click to see full alt table
StatusAccuracyProgram
72.9%
(pow.f64 (sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
98.1%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
98.4%
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
22.8%
(/.f64 (-.f64 (*.f64 #s(literal 3 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
47.5%
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
✓47.6%
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓98.4%
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
98.4%
(/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
✓98.8%
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓98.8%
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
✓98.5%
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓98.4%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
47.5%
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
98.4%
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
98.4%
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
98.4%
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
✓98.0%
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
99.0%
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (log.f64 im))
47.4%
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
30.7%
(sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
72.5%
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
Compiler

Compiled 912 to 362 computations (60.3% saved)

regimes97.0ms (0.4%)

Memory
-9.4MiB live, 191.7MiB allocated
Counts
39 → 1
Calls
Call 1
Inputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(/.f64 (-.f64 (*.f64 #s(literal 3 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
(pow.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (log.f64 im))
(pow.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))) #s(literal -1/2 binary64))
(/.f64 (log.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 10 binary64)))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (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))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (-.f64 (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)))))) (log.f64 #s(literal 10 binary64)))
Outputs
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (log.f64 im))
Calls

8 calls:

18.0ms
(*.f64 re re)
13.0ms
re
11.0ms
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
11.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
11.0ms
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
Results
AccuracySegmentsBranch
99.0%1re
99.0%1im
99.0%1(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
99.0%1(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
99.0%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
99.0%1(+.f64 (*.f64 re re) (*.f64 im im))
99.0%1(*.f64 re re)
99.0%1(*.f64 im im)
Compiler

Compiled 60 to 38 computations (36.7% saved)

regimes76.0ms (0.3%)

Memory
-3.7MiB live, 157.3MiB allocated
Counts
31 → 1
Calls
Call 1
Inputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(sqrt.f64 (pow.f64 (/.f64 (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64)))
(pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))) #s(literal 2 binary64))
(/.f64 (-.f64 (*.f64 #s(literal 3 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
(pow.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
Outputs
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
Calls

8 calls:

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

Compiled 60 to 38 computations (36.7% saved)

regimes28.0ms (0.1%)

Memory
25.9MiB live, 64.6MiB allocated
Accuracy

Total -33.2b remaining (-3407.6%)

Threshold costs -33.2b (-3407.6%)

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

8 calls:

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

Compiled 60 to 38 computations (36.7% saved)

simplify7.0ms (0%)

Memory
-26.0MiB live, 12.5MiB allocated
Algorithm
1×egg-herbie
Rules
4×*-commutative_binary64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01629
11829
Stop Event
1×saturated
Calls
Call 1
Inputs
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (log.f64 im))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
Outputs
(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (log.f64 im))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))

soundness347.0ms (1.4%)

Memory
20.4MiB live, 320.4MiB allocated
Rules
14 804×lower-fma.f64
14 804×lower-fma.f32
5 424×lower-fma.f32
5 420×lower-fma.f64
5 344×lower-*.f32
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
026179
047146
1156146
2941146
08140146
030148
054125
1182111
0994111
02681640
17301596
221981594
358171582
084141470
Stop Event
1×fuel
1×iter limit
1×node limit
1×iter limit
1×iter limit
1×node limit
1×iter limit
1×iter limit
1×node limit
1×iter limit
Compiler

Compiled 82 to 55 computations (32.9% saved)

preprocess105.0ms (0.4%)

Memory
29.8MiB live, 147.7MiB allocated
Compiler

Compiled 174 to 106 computations (39.1% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...