math.abs on complex

Time bar (total: 4.2s)

start0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

analyze0.0ms (0%)

Memory
0.6MiB live, 0.6MiB allocated
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.9%0.1%0%0%0%0
100%99.9%0%0.1%0%0%0%1
Compiler

Compiled 10 to 5 computations (50% saved)

sample743.0ms (17.6%)

Memory
-1.8MiB live, 1 199.4MiB allocated
Samples
569.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 262.0ms
ival-hypot: 253.0ms (96.6% of total)
ival-true: 6.0ms (2.3% of total)
ival-assert: 3.0ms (1.1% of total)
Bogosity

explain106.0ms (2.5%)

Memory
-18.4MiB live, 183.4MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1380-2(2.0498877978083265e-157 6.176446033661168e-273)(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
00-0-(+.f64 (*.f64 re re) (*.f64 im im))
00-0-(*.f64 re re)
00-0-re
00-0-(*.f64 im im)
00-0-im
Explanations
Click to see full explanations table
OperatorSubexpressionExplanationCount
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))oflow-rescue1250
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow125
↳(*.f64 re re)overflow79
↳(*.f64 im im)overflow62
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue110
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow11
↳(*.f64 re re)underflow57
↳(*.f64 im im)underflow59
Confusion
Predicted +Predicted -
+1362
-0118
Precision
1.0
Recall
0.9855072463768116
Confusion?
Predicted +Predicted MaybePredicted -
+13602
-00118
Precision?
1.0
Recall?
0.9855072463768116
Freqs
test
numberfreq
0120
1136
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
45.0ms512×0valid
Compiler

Compiled 60 to 22 computations (63.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 32.0ms
ival-add: 16.0ms (50% of total)
ival-hypot: 8.0ms (25% of total)
ival-mult: 7.0ms (21.9% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

preprocess16.0ms (0.4%)

Memory
38.6MiB live, 38.6MiB allocated
Algorithm
1×egg-herbie
Rules
32×sub-neg
30×distribute-lft-neg-in
30×neg-sub0
28×unsub-neg
24×neg-mul-1
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01642
13542
27742
314542
420442
521742
621942
068
0108
1118
0113
Stop Event
1×iter limit
1×saturated
1×iter limit
1×saturated
Calls
Call 1
Inputs
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Outputs
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
Symmetry

(abs im)

(abs re)

(sort re im)

Compiler

Compiled 10 to 6 computations (40% saved)

eval2.0ms (0%)

Memory
-37.8MiB live, 0.7MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

Memory
3.3MiB live, 3.3MiB allocated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶50.2%
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Compiler

Compiled 10 to 6 computations (40% saved)

simplify3.0ms (0.1%)

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

Found 4 expressions of interest:

NewMetricScoreProgram
cost-diff0
(*.f64 im im)
cost-diff0
(*.f64 re re)
cost-diff0
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
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
0623
01023
11123
01117
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
Outputs
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(+.f64 (*.f64 re re) (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(*.f64 re re)
re
(*.f64 im im)
im

localize22.0ms (0.5%)

Memory
18.8MiB live, 55.8MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
accuracy0
(*.f64 re re)
accuracy0
(*.f64 im im)
accuracy0.00390625
(+.f64 (*.f64 re re) (*.f64 im im))
accuracy31.85839252627237
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Samples
17.0ms256×0valid
Compiler

Compiled 25 to 8 computations (68% saved)

Precisions
Click to see histograms. Total time spent on operations: 11.0ms
ival-hypot: 4.0ms (37.3% of total)
ival-add: 3.0ms (28% of total)
ival-mult: 3.0ms (28% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series7.0ms (0.2%)

Memory
-19.7MiB live, 19.0MiB allocated
Counts
4 → 72
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 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())
#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())
#s(alt (*.f64 im im) (patch (*.f64 im im) #<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 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 (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 (*.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 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 (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 (*.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 (* -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 (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 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 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 (pow im 2) (taylor 0 im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (*.f64 im im) (patch (*.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 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 (pow im 2) (taylor inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (*.f64 im im) (patch (*.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 (* -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>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
Calls

6 calls:

TimeVariablePointExpression
2.0ms
im
@inf
((+ (* re re) (* im im)) (sqrt (+ (* re re) (* im im))) (* re re) (* im im))
1.0ms
re
@0
((+ (* re re) (* im im)) (sqrt (+ (* re re) (* im im))) (* re re) (* im im))
1.0ms
re
@inf
((+ (* re re) (* im im)) (sqrt (+ (* re re) (* im im))) (* re re) (* im im))
1.0ms
re
@-inf
((+ (* re re) (* im im)) (sqrt (+ (* re re) (* im im))) (* re re) (* im im))
1.0ms
im
@0
((+ (* re re) (* im im)) (sqrt (+ (* re re) (* im im))) (* re re) (* im im))

simplify171.0ms (4%)

Memory
0.8MiB live, 281.3MiB allocated
Algorithm
1×egg-herbie
Rules
18 004×lower-fma.f64
18 004×lower-fma.f32
5 072×lower-*.f64
5 072×lower-*.f32
2 260×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0104620
1296620
2953618
33667584
46426582
08051530
Stop Event
1×iter limit
1×node limit
Counts
72 → 68
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))
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)))))
(pow re 2)
(pow re 2)
(pow re 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))))
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)))))))
(pow re 2)
(pow re 2)
(pow re 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 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))))))))
(pow re 2)
(pow re 2)
(pow re 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))
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)))))
(pow im 2)
(pow im 2)
(pow im 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))))
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)))))))
(pow im 2)
(pow im 2)
(pow im 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))))
(* -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))))))))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
Outputs
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
(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) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im 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 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) #s(literal -1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) re) re))) re (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im 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) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)))
(* -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 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64))) 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 im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 im (*.f64 re re)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal 1 binary64))) im (*.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64)))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (*.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)

rewrite261.0ms (6.2%)

Memory
27.4MiB live, 220.4MiB allocated
Rules
5 720×lower-fma.f64
5 720×lower-fma.f32
4 038×lower-/.f64
4 038×lower-/.f32
3 184×lower-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0621
01021
12921
219621
3178821
0862415
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
4 → 245
Calls
Call 1
Inputs
(+.f64 (*.f64 re re) (*.f64 im im))
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(*.f64 re re)
(*.f64 im im)
Outputs
(*.f64 (exp.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (exp.f64 (neg.f64 (log.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (exp.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (exp.f64 (neg.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))
(*.f64 (pow.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))))
(*.f64 (pow.f64 (/.f64 (+.f64 im re) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re)) #s(literal -1 binary64)))
(*.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)))))
(*.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re)))))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal -1 binary64)))
(*.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (fma.f64 im im (*.f64 re re)))
(*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (+.f64 im re))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
(*.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))
(*.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))
(*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re)))))))
(/.f64 (fma.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (pow.f64 (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (-.f64 (*.f64 (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (neg.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (+.f64 im re))) (neg.f64 (-.f64 re im)))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (neg.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (neg.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (neg.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (neg.f64 (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (neg.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (neg.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (neg.f64 (neg.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (neg.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im)))) (neg.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (+.f64 im re)) (-.f64 re im)) (*.f64 (-.f64 re im) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (+.f64 im re)))) (*.f64 (-.f64 re im) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (+.f64 im re)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (-.f64 re im) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im)))) (*.f64 (-.f64 re im) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (+.f64 im re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (-.f64 re im) #s(literal 1 binary64))) (*.f64 (-.f64 re im) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (-.f64 re im) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (-.f64 re im) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (-.f64 re im)) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (+.f64 im re)))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im)))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal 1 binary64))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (-.f64 re im)) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im)))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1 binary64))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (-.f64 re im)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (+.f64 im re)))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im)))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) #s(literal 1 binary64))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (-.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im))) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (exp.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (exp.f64 (log.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (exp.f64 (log.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (exp.f64 (log.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (exp.f64 (log.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (exp.f64 (log.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (exp.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (exp.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (+.f64 im re)) (-.f64 re im))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))) (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (neg.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (neg.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (neg.f64 (*.f64 (neg.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 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 re im) (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (+.f64 im re))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))) (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))
(/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(/.f64 (*.f64 (neg.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 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (-.f64 re im) (+.f64 im re)))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 im im (*.f64 re re))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (fma.f64 im im (*.f64 re re))))
(neg.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (fma.f64 im im (*.f64 re re)) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 (*.f64 re re) re) (+.f64 im re)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 im re)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 re (+.f64 im re)) (/.f64 (*.f64 (*.f64 re re) re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 re (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 re re (*.f64 im im))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))) (/.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))
(-.f64 (/.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))) (/.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 im im) im) im)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 im im) im) im)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (-.f64 re im) (+.f64 im re))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))) (*.f64 (-.f64 re im) (+.f64 im re))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))
(exp.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64)))
(exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re))))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re))))))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re))) (sqrt.f64 (+.f64 im re)))
(*.f64 (pow.f64 (pow.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.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 im re)) #s(literal 1/2 binary64)) (sqrt.f64 (+.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 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (sqrt.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal 1/2 binary64)))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 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 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))))) (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (+.f64 im re))) (sqrt.f64 (-.f64 re im)))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im)))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) re (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (sqrt.f64 (*.f64 (neg.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 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 im re)
(hypot.f64 re im)
(exp.f64 (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))))
(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)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 re re)
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 re))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(*.f64 im im)
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 im))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))

eval86.0ms (2%)

Memory
-4.2MiB live, 117.1MiB allocated
Compiler

Compiled 14 217 to 964 computations (93.2% saved)

prune51.0ms (1.2%)

Memory
-20.4MiB live, 141.0MiB allocated
Pruning

7 alts after pruning (7 fresh and 0 done)

PrunedKeptTotal
New3067313
Fresh000
Picked101
Done000
Total3077314
Accuracy
100.0%
Counts
314 → 7
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶100.0%
(hypot.f64 re im)
▶50.2%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
▶4.5%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
▶49.8%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
94.1%
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
6.4%
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
▶1.7%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Compiler

Compiled 110 to 62 computations (43.6% saved)

simplify5.0ms (0.1%)

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

Found 12 expressions of interest:

NewMetricScoreProgram
cost-diff0
(*.f64 im im)
cost-diff0
(fma.f64 re re (*.f64 im im))
cost-diff0
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
cost-diff0
(*.f64 re re)
cost-diff0
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
cost-diff0
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
cost-diff0
(*.f64 im im)
cost-diff0
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
cost-diff0
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
cost-diff0
(neg.f64 re)
cost-diff0
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
cost-diff5120
(hypot.f64 re im)
Rules
24×lower-+.f64
24×lower-+.f32
12×lower-fma.f32
10×lower-fma.f64
8×lower-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01778
02578
13078
23278
33478
43678
54078
64978
75578
85978
05978
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
(hypot.f64 re im)
re
im
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
re
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(*.f64 im im)
im
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
re
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
Outputs
(hypot.f64 re im)
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
re
im
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
re
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(*.f64 im im)
im
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
re
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(sqrt.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

localize56.0ms (1.3%)

Memory
-7.4MiB live, 119.5MiB allocated
Localize:

Found 12 expressions of interest:

NewMetricScoreProgram
accuracy0
(*.f64 im im)
accuracy0.00390625
(fma.f64 re re (*.f64 im im))
accuracy31.85839252627237
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
accuracy0
(*.f64 re re)
accuracy31.85839252627237
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
accuracy54.909774890785116
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
accuracy0
(*.f64 im im)
accuracy0.2839014798977374
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
accuracy31.85839252627237
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
accuracy0
(neg.f64 re)
accuracy62.889872189742654
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
accuracy0
(hypot.f64 re im)
Samples
23.0ms256×0valid
Compiler

Compiled 81 to 9 computations (88.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 13.0ms
ival-mult: 6.0ms (46.8% of total)
ival-hypot: 4.0ms (31.2% of total)
ival-add: 1.0ms (7.8% of total)
ival-neg: 1.0ms (7.8% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series10.0ms (0.2%)

Memory
-7.4MiB live, 31.7MiB allocated
Counts
11 → 228
Calls
Call 1
Inputs
#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())
#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())
#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())
#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())
#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())
#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())
#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())
#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())
#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())
#s(alt (sqrt.f64 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())
#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())
Outputs
#s(alt im (taylor 0 re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor 0 re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor 0 re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor 0 re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor 0 re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.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 0 re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.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 re (taylor inf re) (#s(alt (sqrt.f64 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.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 (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.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 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 im im)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<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 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) (patch (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (+ (* re re) (* im im)) (*.f64 re re)) (patch #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.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 (fma.f64 re re (*.f64 im im))) (patch (sqrt.f64 (fma.f64 re re (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.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 (fma.f64 re re (*.f64 im im)) (patch (fma.f64 re re (*.f64 im im)) #<representation binary64>) () ())) ())
Calls

6 calls:

TimeVariablePointExpression
1.0ms
re
@-inf
((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)))
1.0ms
re
@inf
((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)))
1.0ms
im
@-inf
((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)))
1.0ms
im
@inf
((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)))
0.0ms
re
@0
((sqrt (+ (* re re) (* im im))) (sqrt (+ (* re re) (* im im))) (neg re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* re re) (sqrt (+ (* re re) (* im im))) (+ (* re re) (* im im)))

simplify200.0ms (4.7%)

Memory
-6.8MiB live, 267.3MiB allocated
Algorithm
1×egg-herbie
Rules
18 004×lower-fma.f64
18 004×lower-fma.f32
5 072×lower-*.f64
5 072×lower-*.f32
2 260×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01042548
12962548
29562538
336812368
464422358
080672134
Stop Event
1×iter limit
1×node limit
Counts
228 → 208
Calls
Call 1
Inputs
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)))))
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)))))
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
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)))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 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)))))
(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)
(pow re 2)
(pow re 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)))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
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)))))))
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 re)
(* -1 re)
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)))))))
(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))))
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)))))))
(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)
(pow re 2)
(pow re 2)
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)))))))
(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 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))))))))
(* -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))))))))
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -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))))))))
(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 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))))))))
(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)
(pow re 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))))))))
(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))))
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)))))
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)))))
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)))))
(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)
(pow im 2)
(pow im 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)))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 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)))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
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)))))))
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)))))))
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)))))))
(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 im 2)
(pow im 2)
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)))))))
(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))))
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)))))))
(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))))
(* -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))))))))
(* -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))))))))
(* -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))))))))
(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 im 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))))))))
(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))))
(* -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))))))))
(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))))
Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im 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 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) (*.f64 (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 (*.f64 re re) re) re)) #s(literal -1/8 binary64) #s(literal 1 binary64))) re))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im 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 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) (*.f64 (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 (*.f64 re re) re) re)) #s(literal -1/8 binary64) #s(literal 1 binary64))) re))
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im 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 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) (*.f64 (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 (*.f64 re re) re) re)) #s(literal -1/8 binary64) #s(literal 1 binary64))) re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im 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 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) (*.f64 (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 (*.f64 re re) re) re)) #s(literal -1/8 binary64) #s(literal 1 binary64))) re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im 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 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) (*.f64 (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 (*.f64 re re) re) re)) #s(literal -1/8 binary64) #s(literal 1 binary64))) re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)))
(* -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 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)))
(* -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 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)))
(* -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 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)))
(* -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 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)))
(* -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 (*.f64 #s(literal -1/2 binary64) (/.f64 im re)) im (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64))) re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 im (*.f64 re re)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 im (*.f64 re re)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 im (*.f64 re re)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 im (*.f64 re re)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 im (*.f64 re re)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) (*.f64 (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 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) #s(literal 1 binary64))) im))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) (*.f64 (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 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) #s(literal 1 binary64))) im))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) (*.f64 (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 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) #s(literal 1 binary64))) im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) (*.f64 (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 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) #s(literal 1 binary64))) im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) (*.f64 (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 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) #s(literal 1 binary64))) im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (*.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (*.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (*.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (*.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (*.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (*.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64))) im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))

rewrite180.0ms (4.3%)

Memory
22.2MiB live, 342.2MiB allocated
Rules
6 048×lower-fma.f32
6 046×lower-fma.f64
3 332×lower-*.f32
3 328×lower-*.f64
3 228×lower-/.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01768
02568
15068
223968
3197668
0856668
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
11 → 403
Calls
Call 1
Inputs
(hypot.f64 re im)
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(*.f64 im im)
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
Outputs
(*.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re))))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re))) (sqrt.f64 (+.f64 im re)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (pow.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 im re)))
(*.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (sqrt.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal 1/2 binary64)))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 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 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))))) (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (+.f64 im re))) (sqrt.f64 (-.f64 re im)))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im)))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (sqrt.f64 (*.f64 (neg.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 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im 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) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re im)
(exp.f64 (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))))
(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)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(*.f64 (*.f64 (neg.f64 re) re) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 (*.f64 re re) (neg.f64 re)) (/.f64 #s(literal 1 binary64) (*.f64 re re)))
(*.f64 #s(literal -1 binary64) re)
(*.f64 re #s(literal -1 binary64))
(pow.f64 (/.f64 re (*.f64 (neg.f64 re) re)) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 re re) (neg.f64 re))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (/.f64 #s(literal 0 binary64) re) #s(literal 3 binary64)) (*.f64 (*.f64 re re) re)) (fma.f64 (/.f64 #s(literal 0 binary64) re) (/.f64 #s(literal 0 binary64) re) (fma.f64 re re (*.f64 (/.f64 #s(literal 0 binary64) re) re))))
(/.f64 (-.f64 (pow.f64 (/.f64 #s(literal 0 binary64) (*.f64 re re)) #s(literal 3 binary64)) (*.f64 (*.f64 re re) re)) (fma.f64 (/.f64 #s(literal 0 binary64) (*.f64 re re)) (/.f64 #s(literal 0 binary64) (*.f64 re re)) (fma.f64 re re (*.f64 (/.f64 #s(literal 0 binary64) (*.f64 re re)) re))))
(/.f64 (fma.f64 (*.f64 re re) (neg.f64 re) #s(literal 0 binary64)) (fma.f64 re re (-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 re) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (neg.f64 re) re))) (neg.f64 (neg.f64 re)))
(/.f64 (neg.f64 (neg.f64 (*.f64 (*.f64 re re) (neg.f64 re)))) (neg.f64 (*.f64 (neg.f64 re) re)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (*.f64 re re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re))) (*.f64 (*.f64 (*.f64 re re) re) re))
(/.f64 (neg.f64 (*.f64 (neg.f64 re) re)) (neg.f64 (-.f64 #s(literal 0 binary64) (neg.f64 re))))
(/.f64 (neg.f64 (*.f64 (neg.f64 re) re)) (neg.f64 re))
(/.f64 (neg.f64 (*.f64 (*.f64 re re) (neg.f64 re))) (neg.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 #s(literal 0 binary64) (neg.f64 re))))))
(/.f64 (neg.f64 (*.f64 (*.f64 re re) (neg.f64 re))) (*.f64 (neg.f64 re) re))
(/.f64 (*.f64 (neg.f64 re) re) (-.f64 #s(literal 0 binary64) (neg.f64 re)))
(/.f64 (*.f64 (neg.f64 re) re) re)
(/.f64 #s(literal 1 binary64) (/.f64 re (*.f64 (neg.f64 re) re)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 (*.f64 re re) (neg.f64 re))))
(/.f64 (*.f64 (*.f64 re re) (neg.f64 re)) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 #s(literal 0 binary64) (neg.f64 re)))))
(/.f64 (*.f64 (*.f64 re re) (neg.f64 re)) (*.f64 re re))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 re (*.f64 (neg.f64 re) re))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 re re) (*.f64 (*.f64 re re) (neg.f64 re)))))
(neg.f64 re)
(fma.f64 (*.f64 (neg.f64 re) re) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (*.f64 (*.f64 re re) (neg.f64 re)) (/.f64 #s(literal 1 binary64) (*.f64 re re)) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) re #s(literal 0 binary64))
(fma.f64 re #s(literal -1 binary64) #s(literal 0 binary64))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (neg.f64 re))) (/.f64 (*.f64 re re) (-.f64 #s(literal 0 binary64) (neg.f64 re))))
(-.f64 (/.f64 #s(literal 0 binary64) re) re)
(-.f64 (/.f64 #s(literal 0 binary64) (*.f64 re re)) re)
(-.f64 #s(literal 0 binary64) re)
(+.f64 #s(literal 0 binary64) (neg.f64 re))
(+.f64 (neg.f64 re) #s(literal 0 binary64))
(*.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(literal 1/4 binary64)))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))))
(pow.f64 (*.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(literal 1/2 binary64))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(exp.f64 (fma.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #s(literal 1/4 binary64) (*.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #s(literal 1/4 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(approx (+ (* re re) (* im im)) (*.f64 im im)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #s(literal 1/2 binary64)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(exp.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im))))
(*.f64 im im)
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 im))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(*.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(literal 1/4 binary64)))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))))
(pow.f64 (*.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(literal 1/2 binary64))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
(exp.f64 (fma.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #s(literal 1/4 binary64) (*.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #s(literal 1/4 binary64))))
(exp.f64 (*.f64 (*.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(approx (+ (* re re) (* im im)) (*.f64 re re)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #s(literal 1/2 binary64)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(exp.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re))))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 re re)
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 re))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 re #s(literal 2 binary64))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) #s(literal 0 binary64))) (neg.f64 (-.f64 (*.f64 re re) #s(literal 0 binary64))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) #s(literal 0 binary64))) (neg.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 re re) #s(literal 0 binary64))))))
(/.f64 (neg.f64 (+.f64 #s(literal 0 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 #s(literal 0 binary64) (*.f64 re re))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (neg.f64 (*.f64 (neg.f64 re) re)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (neg.f64 re) re))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) #s(literal 0 binary64)) (-.f64 (*.f64 re re) #s(literal 0 binary64)))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re) #s(literal 0 binary64)) (fma.f64 (*.f64 (*.f64 re re) re) re (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 re re) #s(literal 0 binary64)))))
(/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 #s(literal 0 binary64) (*.f64 re re)))))
(fma.f64 (neg.f64 re) (neg.f64 re) #s(literal 0 binary64))
(fma.f64 re re #s(literal 0 binary64))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (-.f64 (*.f64 re re) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) #s(literal 0 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (*.f64 re re)) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (neg.f64 re) re)))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 #s(literal 0 binary64) (*.f64 re re))
(+.f64 (*.f64 re re) #s(literal 0 binary64))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re))))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re))) (sqrt.f64 (+.f64 im re)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (pow.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 im re)))
(*.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (sqrt.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal 1/2 binary64)))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 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 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))))) (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (+.f64 im re))) (sqrt.f64 (-.f64 re im)))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im)))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (sqrt.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (sqrt.f64 (*.f64 (neg.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 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (sqrt.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im 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) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re im)
(exp.f64 (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))))
(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)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (exp.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (exp.f64 (neg.f64 (log.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (exp.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (exp.f64 (neg.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))
(*.f64 (pow.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(*.f64 (pow.f64 (/.f64 (+.f64 im re) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal -1 binary64)))
(*.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)))))
(*.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re)))))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 (neg.f64 im) im) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 re re) (*.f64 (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im))))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (-.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)))))
(*.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (fma.f64 im im (*.f64 re re)))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal -1 binary64)))
(*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (+.f64 im re))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))
(*.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))
(*.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))
(*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))))
(pow.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im 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 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re)))))))
(/.f64 (fma.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (pow.f64 (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (-.f64 (*.f64 (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (neg.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (+.f64 im re))) (neg.f64 (-.f64 re im)))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))))) (neg.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (neg.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))) (neg.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (neg.f64 (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))) (neg.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (neg.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (neg.f64 (neg.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (neg.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im)))) (neg.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (+.f64 im re)) (-.f64 re im)) (*.f64 (-.f64 re im) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (+.f64 im re)))) (*.f64 (-.f64 re im) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (+.f64 im re)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (-.f64 re im) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im)))) (*.f64 (-.f64 re im) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (+.f64 im re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (-.f64 re im) #s(literal 1 binary64))) (*.f64 (-.f64 re im) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (-.f64 re im) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (-.f64 re im) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (-.f64 re im)) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (+.f64 im re)))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im)))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal 1 binary64))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (-.f64 re im)) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im)))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1 binary64))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (-.f64 re im)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (+.f64 im re)))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im)))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) #s(literal 1 binary64))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (-.f64 (neg.f64 (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (neg.f64 im) (*.f64 (*.f64 im im) im))) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (exp.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (exp.f64 (log.f64 (*.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))))) (exp.f64 (log.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (exp.f64 (log.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))) (exp.f64 (log.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (exp.f64 (log.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (exp.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (exp.f64 (log.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (+.f64 im re)) (-.f64 re im))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))) (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (neg.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (neg.f64 (*.f64 (neg.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 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)))) (neg.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im 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 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))
(/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(/.f64 (*.f64 (neg.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 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (*.f64 (-.f64 re im) (+.f64 im re)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im 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 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 im im (*.f64 re re))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (fma.f64 im im (*.f64 re re))))
(neg.f64 (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(neg.f64 (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (fma.f64 (*.f64 (*.f64 re re) re) re (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im))) (fma.f64 im im (*.f64 re re)) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 (*.f64 re re) re) (+.f64 im re)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 im re)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 re (+.f64 im re)) (/.f64 (*.f64 (*.f64 re re) re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(fma.f64 re (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 re re (*.f64 im im))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))) (/.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (*.f64 (*.f64 re re) re) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))
(-.f64 (/.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))) (/.f64 (*.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (*.f64 (*.f64 im im) im) im)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 im im) im) im)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re)))))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (-.f64 re im)) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))) (/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (*.f64 (*.f64 im im) im) im)) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (-.f64 re im) (+.f64 im re))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 re re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 (*.f64 re re) re) re))))) (*.f64 (-.f64 re im) (+.f64 im re))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (fma.f64 (*.f64 re re) re (*.f64 (*.f64 im im) im)) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) (fma.f64 (*.f64 (*.f64 im im) im) im (*.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (+.f64 im re) (-.f64 im re))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re))))
(exp.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64)))
(exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 (-.f64 re im) (+.f64 im re)))))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))

eval74.0ms (1.7%)

Memory
-4.8MiB live, 145.6MiB allocated
Compiler

Compiled 19 556 to 1 111 computations (94.3% saved)

prune54.0ms (1.3%)

Memory
-1.2MiB live, 122.1MiB allocated
Pruning

7 alts after pruning (2 fresh and 5 done)

PrunedKeptTotal
New6290629
Fresh022
Picked055
Done000
Total6297636
Accuracy
100.0%
Counts
636 → 7
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓100.0%
(hypot.f64 re im)
✓50.2%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
✓4.5%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
✓49.8%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
▶94.1%
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
▶6.4%
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
✓1.7%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Compiler

Compiled 55 to 31 computations (43.6% saved)

simplify6.0ms (0.1%)

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

Found 8 expressions of interest:

NewMetricScoreProgram
cost-diff0
(*.f64 re re)
cost-diff0
(/.f64 #s(literal 1/2 binary64) im)
cost-diff0
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
cost-diff0
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
cost-diff0
(/.f64 im re)
cost-diff0
(*.f64 #s(literal 1/2 binary64) im)
cost-diff0
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
cost-diff0
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
Rules
84×lower-*.f32
80×lower-*.f64
36×lower-fma.f32
32×*-commutative
32×lower-fma.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01568
02368
13768
25768
37168
47968
58268
08258
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(*.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(/.f64 im re)
re
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(*.f64 re re)
re
Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re)
(*.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(/.f64 im re)
re
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(*.f64 re re)
re

localize35.0ms (0.8%)

Memory
-13.7MiB live, 64.0MiB allocated
Localize:

Found 8 expressions of interest:

NewMetricScoreProgram
accuracy0
(/.f64 #s(literal 1/2 binary64) im)
accuracy0
(*.f64 re re)
accuracy0.09924122650394328
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
accuracy3.706386983967961
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
accuracy0
(/.f64 im re)
accuracy0
(*.f64 #s(literal 1/2 binary64) im)
accuracy0.1328125
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
accuracy59.882971573909664
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
Samples
26.0ms256×0valid
Compiler

Compiled 54 to 14 computations (74.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 17.0ms
ival-mult: 6.0ms (34.6% of total)
ival-div: 5.0ms (28.9% of total)
ival-hypot: 4.0ms (23.1% of total)
ival-add: 2.0ms (11.5% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series15.0ms (0.3%)

Memory
28.8MiB live, 28.8MiB allocated
Counts
8 → 156
Calls
Call 1
Inputs
#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())
#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())
#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())
#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())
#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())
#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())
Outputs
#s(alt im (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow im 2) re)) (taylor 0 re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re) (taylor 0 re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re) (taylor 0 re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow im 2)) (pow re 2)) re) (taylor 0 re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 re (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<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 (* -1 re) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt re (taylor -inf re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1))) (taylor -inf re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1))) (taylor -inf re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1))) (taylor -inf re) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf re) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<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 re (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor 0 im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor 0 im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor 0 im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow im 2) re)) (taylor inf im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow im 2) re)) (taylor -inf im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) (patch (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 im) (taylor -inf im) (#s(alt (*.f64 #s(literal 1/2 binary64) im) (patch (*.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ im re) (taylor -inf im) (#s(alt (/.f64 im re) (patch (/.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) (patch (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ 1/2 im) (taylor -inf im) (#s(alt (/.f64 #s(literal 1/2 binary64) im) (patch (/.f64 #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
Calls

6 calls:

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

simplify215.0ms (5.1%)

Memory
-33.1MiB live, 256.9MiB allocated
Algorithm
1×egg-herbie
Rules
18 896×lower-fma.f64
18 896×lower-fma.f32
4 560×lower-*.f64
4 560×lower-*.f32
2 412×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01231432
13291432
210441428
339281300
474061300
084041200
Stop Event
1×iter limit
1×node limit
Counts
156 → 142
Calls
Call 1
Inputs
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)))))
(* 1/2 (/ (pow im 2) re))
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
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)))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
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)))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(/ im re)
(/ im re)
(/ im re)
(/ im re)
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/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))))
(pow re 2)
(pow re 2)
(pow re 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
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(* -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))))))))
(* 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))))
(pow re 2)
(pow re 2)
(pow re 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)))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* 1/2 (/ (pow im 2) re)))
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
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)))))
(* 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)
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
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/2 (/ (pow im 2) re))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(/ im re)
(/ im re)
(/ im re)
(/ im 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)))))))
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)))))
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
(* -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))))))))
(* 1/2 (/ (pow im 2) re))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(* -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))))))))
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 im)
(/ 1/2 im)
(/ 1/2 im)
(/ 1/2 im)
Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
(* 1/2 (/ (pow im 2) re))
(*.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) (*.f64 re re)) re)
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) (*.f64 re re)) re)
(/ (+ (* 1/2 (pow im 2)) (pow re 2)) re)
(/.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) (*.f64 re re)) re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) 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 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im (*.f64 (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 (*.f64 re re) re) re)) #s(literal -1/8 binary64) #s(literal 1 binary64))) re))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) 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 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im (*.f64 (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 (*.f64 re re) re) re)) #s(literal -1/8 binary64) #s(literal 1 binary64))) re))
(* 1/2 (/ (pow re 2) im))
(*.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(neg.f64 (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)))
(* -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))))))))
(neg.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im (*.f64 (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 (*.f64 re re) re) re)) #s(literal -1/8 binary64) #s(literal 1 binary64))) re)))
re
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* -1 (* re (- (* -1/2 (/ (pow im 2) (pow re 2))) 1)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(neg.f64 (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)))
(* -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))))))))
(neg.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) re) im) im (*.f64 (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 (*.f64 re re) re) re)) #s(literal -1/8 binary64) #s(literal 1 binary64))) re)))
(* 1/2 (/ (pow re 2) im))
(*.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 im (*.f64 re re)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 im (*.f64 re re)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(* 1/2 (/ (pow re 2) im))
(*.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (*.f64 re re) #s(literal 1/2 binary64) (*.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (*.f64 re re) #s(literal 1/2 binary64) (*.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (*.f64 re re) #s(literal 1/2 binary64) (*.f64 im im)) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) (*.f64 (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 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) #s(literal 1 binary64))) im))
(* 1/2 (/ (pow im 2) re))
(*.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) (*.f64 (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 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) #s(literal 1 binary64))) im))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(neg.f64 (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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))))))))
(neg.f64 (fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) (*.f64 (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 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) #s(literal 1 binary64))) im)))
(* 1/2 (/ (pow im 2) re))
(*.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* (pow im 2) (+ (* 1/2 (/ 1 re)) (/ re (pow im 2))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(neg.f64 (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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))))))))
(neg.f64 (fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) (*.f64 (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 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) #s(literal 1 binary64))) im)))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)
(/ 1/2 im)
(/.f64 #s(literal 1/2 binary64) im)

rewrite167.0ms (3.9%)

Memory
38.0MiB live, 187.2MiB allocated
Rules
9 152×lower-fma.f32
9 148×lower-fma.f64
5 678×lower-*.f32
5 674×lower-*.f64
3 360×lower-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01562
02362
19162
264762
0818252
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
8 → 239
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(*.f64 #s(literal 1/2 binary64) im)
(/.f64 im re)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/.f64 #s(literal 1/2 binary64) im)
(*.f64 re re)
Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re))
(*.f64 (/.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re)) (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (neg.f64 re) re) re))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re))))
(*.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64))))))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64))))))
(*.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (fma.f64 (*.f64 (*.f64 (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64))) re) (*.f64 (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64))) re)) (*.f64 (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64))) re) (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))) (fma.f64 (*.f64 (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64))) re) (-.f64 (*.f64 (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64))) re) (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)))) (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) re) re))))
(*.f64 (/.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re))) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re))
(*.f64 (fma.f64 re re (*.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64)))))
(*.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)))
(*.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)))
(*.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)))))
(*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re)) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)))
(*.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re))
(*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)) (/.f64 (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))))
(*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)) (*.f64 (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)))))
(*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))))
(*.f64 (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re) (/.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))))
(*.f64 (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re)) #s(literal -1 binary64))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re re)))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))) (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re re)) (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) re) re))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (neg.f64 re) re) re)))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (pow.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)))) (fma.f64 (*.f64 (*.f64 re re) re) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)))) (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))))
(/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re)) #s(literal 1 binary64)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)))
(/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) #s(literal 1 binary64)) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)))) (*.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)) (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)))) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) (fma.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)) (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)) (*.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))))
(/.f64 (neg.f64 (fma.f64 re re (*.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 re re))))) (neg.f64 (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re)))) (neg.f64 (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)))) (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1 binary64)) (*.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re re)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re re)) (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) re) re))) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) #s(literal 1 binary64)) (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (neg.f64 re) re) re)) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (pow.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) #s(literal 9 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 re re) re) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)))) (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))))
(/.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im))) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re re))))
(/.f64 (fma.f64 re re (*.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 re re)))) (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (fma.f64 (*.f64 re re) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re re)) (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) re) re)))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)) (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (neg.f64 re) re) re))))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (pow.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) #s(literal 9 binary64))) (*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)) (fma.f64 (*.f64 (*.f64 re re) re) (-.f64 (*.f64 (*.f64 re re) re) (*.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)))) (/.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))))))
(/.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re))) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))
(/.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re))) (neg.f64 (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re))))
(/.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64))) (fma.f64 re re (*.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re)))
(/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re))) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re))) (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))))
(neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re)) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)))
(neg.f64 (/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (neg.f64 (fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re)))))
(fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64)) (/.f64 im re) re)
(fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) (neg.f64 re)) (neg.f64 im) re)
(fma.f64 (/.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 re re) re)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (neg.f64 re) re) re))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (/.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (neg.f64 re) re))) (fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (pow.f64 re #s(literal 1/2 binary64)) (pow.f64 re #s(literal 1/2 binary64)) (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im))
(fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal -1 binary64)) (/.f64 (neg.f64 im) re) re)
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 im (/.f64 #s(literal 1 binary64) im)) re)
(fma.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) im) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) re)
(fma.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/2 binary64) im)) (/.f64 (*.f64 #s(literal 1/2 binary64) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (*.f64 (*.f64 (*.f64 (/.f64 im re) im) #s(literal 1/4 binary64)) im) (/.f64 (/.f64 im re) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (*.f64 (*.f64 (/.f64 im re) im) #s(literal 1/4 binary64)) (/.f64 (*.f64 (/.f64 im re) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im re)
(fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (/.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 #s(literal 1/4 binary64) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 re re)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 im im)) (/.f64 #s(literal -1 binary64) re) re)
(fma.f64 #s(literal -1 binary64) (neg.f64 re) (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im))
(fma.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) im) im) (/.f64 #s(literal 1 binary64) re) re)
(fma.f64 (*.f64 (/.f64 im re) im) #s(literal 1/2 binary64) re)
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1 binary64) im)) re)
(fma.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 (*.f64 #s(literal 1/2 binary64) im) im) re)
(fma.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) re)
(fma.f64 #s(literal 1 binary64) re (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im))
(fma.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im))) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (neg.f64 im) (/.f64 (*.f64 #s(literal 1/2 binary64) im) (neg.f64 re)) re)
(fma.f64 (neg.f64 im) (*.f64 (/.f64 #s(literal -1 binary64) re) (*.f64 #s(literal 1/2 binary64) im)) re)
(fma.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (/.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (/.f64 im re) (/.f64 (*.f64 (*.f64 (*.f64 (/.f64 im re) im) #s(literal 1/4 binary64)) im) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (/.f64 im re) (/.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) im)) re)
(fma.f64 (/.f64 im re) (*.f64 #s(literal 1/2 binary64) im) re)
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/2 binary64) im)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re)
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) im) im) (*.f64 re re)) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 im re) im) re)
(fma.f64 (*.f64 im im) (*.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re)
(fma.f64 im (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) re)
(fma.f64 re #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im))
(-.f64 (/.f64 (*.f64 re re) (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64)))) (/.f64 (*.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (*.f64 #s(literal 1/4 binary64) (*.f64 im im))) (+.f64 re (*.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64)))))
(-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re)))
(+.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (neg.f64 re)) (*.f64 re re))) (neg.f64 (/.f64 (*.f64 (neg.f64 re) re) (fma.f64 (*.f64 (/.f64 im re) im) #s(literal -1/2 binary64) re))))
(+.f64 (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im) re)
(+.f64 re (*.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im))
(*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) im))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) im)
(*.f64 im #s(literal 1/2 binary64))
(*.f64 (pow.f64 (/.f64 re im) #s(literal -1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (/.f64 #s(literal -1 binary64) re))
(*.f64 (/.f64 #s(literal -1 binary64) re) (neg.f64 im))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 im) re))
(*.f64 (/.f64 #s(literal 1 binary64) re) (pow.f64 (/.f64 #s(literal 1 binary64) im) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) re) im)
(*.f64 #s(literal 1 binary64) (/.f64 im re))
(*.f64 (neg.f64 im) (/.f64 #s(literal -1 binary64) re))
(*.f64 (/.f64 im re) #s(literal 1 binary64))
(*.f64 im (/.f64 #s(literal 1 binary64) re))
(pow.f64 (/.f64 re im) #s(literal -1 binary64))
(/.f64 (*.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(/.f64 (*.f64 #s(literal 1 binary64) (neg.f64 im)) (neg.f64 re))
(/.f64 #s(literal -1 binary64) (/.f64 (neg.f64 re) im))
(/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) im))
(/.f64 #s(literal 1 binary64) (/.f64 re im))
(/.f64 (neg.f64 im) (neg.f64 re))
(/.f64 im re)
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 re im)))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (neg.f64 im) re)))
(neg.f64 (/.f64 (neg.f64 im) re))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 re)) (/.f64 (neg.f64 im) re))
(-.f64 #s(literal 0 binary64) (/.f64 (neg.f64 im) re))
(exp.f64 (*.f64 (log.f64 (/.f64 re im)) #s(literal -1 binary64)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(*.f64 (/.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im)) (fma.f64 (*.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (neg.f64 im) im) im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 im (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))))
(*.f64 (/.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im)) (*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) re)) re (*.f64 (neg.f64 im) (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im)))))) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 (*.f64 re re) re)) re (*.f64 (neg.f64 im) (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im)))))
(*.f64 (/.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im)) (fma.f64 (*.f64 (*.f64 (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im)) im) (*.f64 (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im)) im)) (*.f64 (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im)) im) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))) (fma.f64 (*.f64 (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im)) im) (-.f64 (*.f64 (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im)) im) (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re))) (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (*.f64 (*.f64 im im) im) im))))
(*.f64 (/.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im)) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(*.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re))) (/.f64 #s(literal 1 binary64) (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im))))
(*.f64 (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im)))
(*.f64 (neg.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(*.f64 (neg.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)))))
(*.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im)) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(*.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)) (/.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))))
(*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)))))
(*.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))))
(*.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))))
(*.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)) #s(literal -1 binary64))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (*.f64 (*.f64 im im) im) im)) (*.f64 (*.f64 (*.f64 im im) im) im)) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 im im)))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 im im)) (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)))) (fma.f64 (*.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (neg.f64 im) im) im)))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (pow.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im im) im) (-.f64 (*.f64 (*.f64 im im) im) (*.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im)) #s(literal 1 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)))
(/.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im)) #s(literal 1 binary64)) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)) (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))) (+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)) (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)) (*.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))))
(/.f64 (neg.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re)))) (neg.f64 (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im)))) (neg.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im)))) (neg.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (*.f64 (*.f64 im im) im) im)) (*.f64 (*.f64 (*.f64 im im) im) im)) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 im im)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 im im)) (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (*.f64 (*.f64 im im) im) im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (neg.f64 im) im) im)) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (pow.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) #s(literal 9 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) im) (-.f64 (*.f64 (*.f64 im im) im) (*.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (*.f64 (*.f64 im im) im) im)) (*.f64 (*.f64 (*.f64 im im) im) im)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 im im))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 im im)) (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re))) (*.f64 (*.f64 (*.f64 im im) im) im)))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))) (*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)) (fma.f64 (*.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (neg.f64 im) im) im))))
(/.f64 (-.f64 (*.f64 im im) (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re))) (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im)))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (pow.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) #s(literal 9 binary64))) (*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)) (fma.f64 (*.f64 (*.f64 im im) im) (-.f64 (*.f64 (*.f64 im im) im) (*.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (/.f64 (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re))) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)))) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im))) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))
(/.f64 (neg.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im))) (neg.f64 (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))))
(/.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im)) (-.f64 (*.f64 im im) (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)))
(/.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im)) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))))
(neg.f64 (/.f64 (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im)) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(neg.f64 (/.f64 (fma.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 im im) im)) (neg.f64 (fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 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) (neg.f64 im)) #s(literal -1/2 binary64) im)
(fma.f64 (/.f64 (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re)) (fma.f64 (*.f64 (/.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 re re) re)) (*.f64 (*.f64 re re) re) (*.f64 (*.f64 (neg.f64 im) im) im))) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 im (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (/.f64 (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re)) (fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re) (*.f64 (neg.f64 im) im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)) (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))
(fma.f64 (/.f64 (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im) im)
(fma.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
(fma.f64 (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re re)) re) (/.f64 re (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (/.f64 re im) re)) (/.f64 (/.f64 #s(literal 1/2 binary64) im) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re im) im)
(fma.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re re)) (/.f64 (*.f64 re re) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) (/.f64 #s(literal -1 binary64) im) im)
(fma.f64 #s(literal -1 binary64) (neg.f64 im) (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))
(fma.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) (*.f64 (/.f64 re im) re)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re im)
(fma.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 (*.f64 re re) #s(literal 2 binary64)) im)
(fma.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)
(fma.f64 (/.f64 re im) (/.f64 re #s(literal 2 binary64)) im)
(fma.f64 #s(literal 1 binary64) (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) im)
(fma.f64 #s(literal 1 binary64) im (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))
(fma.f64 (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re)) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (/.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) (neg.f64 im)) im)
(fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 #s(literal -1 binary64) im) (*.f64 re re)) im)
(fma.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (/.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) (*.f64 re re)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (*.f64 (/.f64 re im) re)) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(fma.f64 (/.f64 #s(literal 1/2 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 (/.f64 re im) re) #s(literal 1/2 binary64)))
(fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)
(-.f64 (/.f64 (*.f64 im im) (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im))) (/.f64 (*.f64 (*.f64 (/.f64 #s(literal 1/4 binary64) (*.f64 im im)) re) (*.f64 (*.f64 re re) re)) (+.f64 im (/.f64 (*.f64 #s(literal -1/2 binary64) (*.f64 re re)) im))))
(-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(+.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) re) re)) (*.f64 (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) (neg.f64 im)) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 (neg.f64 im) im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(+.f64 (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)) im)
(+.f64 im (*.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) im) #s(literal -1/2 binary64)) (pow.f64 (*.f64 #s(literal 2 binary64) im) #s(literal -1/2 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -1/2 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1/2 binary64) im))
(*.f64 (/.f64 #s(literal 1 binary64) im) #s(literal 1/2 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) im))
(pow.f64 (*.f64 #s(literal 2 binary64) im) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (*.f64 im #s(literal -2 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) im) #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (*.f64 #s(literal 2 binary64) im))
(/.f64 #s(literal -1/2 binary64) (neg.f64 im))
(/.f64 #s(literal 1/2 binary64) im)
(neg.f64 (/.f64 #s(literal -1 binary64) (*.f64 #s(literal 2 binary64) im)))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) im)))
(neg.f64 (/.f64 #s(literal -1/2 binary64) im))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal -1/2 binary64) im))
(exp.f64 (*.f64 (log.f64 (*.f64 #s(literal 2 binary64) im)) #s(literal -1 binary64)))
(*.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)))
(*.f64 #s(literal 1 binary64) (*.f64 re re))
(*.f64 (*.f64 re re) #s(literal 1 binary64))
(*.f64 re re)
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))

eval55.0ms (1.3%)

Memory
-34.6MiB live, 89.2MiB allocated
Compiler

Compiled 10 239 to 676 computations (93.4% saved)

prune59.0ms (1.4%)

Memory
31.6MiB live, 70.3MiB allocated
Pruning

5 alts after pruning (1 fresh and 4 done)

PrunedKeptTotal
New3801381
Fresh000
Picked202
Done145
Total3835388
Accuracy
100.0%
Counts
388 → 5
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓50.2%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
✓4.5%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
✓49.8%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
▶99.8%
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
✓1.7%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Compiler

Compiled 39 to 22 computations (43.6% saved)

simplify5.0ms (0.1%)

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

Found 4 expressions of interest:

NewMetricScoreProgram
cost-diff0
(/.f64 re im)
cost-diff0
(*.f64 (/.f64 re im) re)
cost-diff0
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
cost-diff0
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
Rules
44×lower-*.f32
42×lower-*.f64
20×lower-fma.f32
18×lower-fma.f64
14×associate-*r*
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01136
01536
12236
23536
34136
44436
54736
04731
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
(*.f64 (/.f64 re im) re)
(/.f64 re im)
re
im
#s(literal 1/2 binary64)
Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im))
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)
(*.f64 (/.f64 re im) re)
(/.f64 re im)
re
im
#s(literal 1/2 binary64)

localize47.0ms (1.1%)

Memory
-32.2MiB live, 42.8MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
accuracy0
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
accuracy0
(/.f64 re im)
accuracy0.09924122650394328
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
accuracy0.14453125
(*.f64 (/.f64 re im) re)
Samples
39.0ms256×0valid
Compiler

Compiled 30 to 10 computations (66.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 32.0ms
ival-add: 22.0ms (69.7% of total)
ival-hypot: 4.0ms (12.7% of total)
ival-mult: 3.0ms (9.5% of total)
ival-div: 2.0ms (6.3% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series8.0ms (0.2%)

Memory
19.5MiB live, 19.5MiB allocated
Counts
4 → 96
Calls
Call 1
Inputs
#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())
#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())
#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())
#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())
Outputs
#s(alt im (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf re) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf re) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor 0 im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor 0 im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor inf im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) 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 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) (patch #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)) #<representation binary64>) () ())) ())
#s(alt im (taylor -inf im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) (patch (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ (pow re 2) im) (taylor -inf im) (#s(alt (*.f64 (/.f64 re im) re) (patch (*.f64 (/.f64 re im) re) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
#s(alt (/ re im) (taylor -inf im) (#s(alt (/.f64 re im) (patch (/.f64 re im) #<representation binary64>) () ())) ())
Calls

6 calls:

TimeVariablePointExpression
1.0ms
im
@-inf
((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))
1.0ms
re
@-inf
((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))
1.0ms
re
@inf
((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))
1.0ms
re
@0
((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))
1.0ms
im
@0
((sqrt (+ (* re re) (* im im))) (+ (* (* (/ re im) re) 1/2) im) (* (/ re im) re) (/ re im))

simplify219.0ms (5.2%)

Memory
0.0MiB live, 244.8MiB allocated
Algorithm
1×egg-herbie
Rules
17 774×lower-fma.f64
17 774×lower-fma.f32
4 270×lower-*.f64
4 270×lower-*.f32
2 472×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0111788
1302788
2977786
33647750
47514750
08243700
Stop Event
1×iter limit
1×node limit
Counts
96 → 89
Calls
Call 1
Inputs
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)))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re 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/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))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(* -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))))))))
(* 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))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
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)))))
(* 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)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
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)))))))
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)))))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(* -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))))))))
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)))
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ (pow re 2) im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) im))) (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) re) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im 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 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) #s(literal -1/8 binary64)) im) (/.f64 im (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) #s(literal 1 binary64))) re))
(* 1/2 (/ (pow re 2) im))
(*.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re) (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) re) re)) #s(literal 1/8 binary64) #s(literal -1 binary64)) re (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)))
(* -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))))))))
(neg.f64 (fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 im im) #s(literal -1/8 binary64)) im) (/.f64 im (*.f64 (*.f64 (*.f64 re re) re) re)) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) #s(literal 1 binary64))) re)))
(* 1/2 (/ (pow re 2) im))
(*.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 (/.f64 im re) #s(literal 1/2 binary64)) im re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 im (*.f64 re re)) #s(literal 1/2 binary64)) 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 (fma.f64 (fma.f64 (*.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) re))) (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(* 1/2 (/ (pow re 2) im))
(*.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (*.f64 re re) #s(literal 1/2 binary64) (*.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (*.f64 re re) #s(literal 1/2 binary64) (*.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 (*.f64 re re) #s(literal 1/2 binary64) (*.f64 im im)) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/8 binary64) im) (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) 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 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re (*.f64 (fma.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 re re)) re) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) #s(literal 1 binary64))) im))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) re) re) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64)) im (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) 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))))))))
(neg.f64 (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) re (*.f64 (fma.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 re re)) re) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) #s(literal 1 binary64))) im)))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)

rewrite244.0ms (5.8%)

Memory
-1.5MiB live, 188.4MiB allocated
Rules
6 318×lower-fma.f32
6 316×lower-fma.f64
4 028×lower-*.f32
4 026×lower-*.f64
2 024×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01133
01533
15833
241833
3480433
0821228
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
4 → 158
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
(*.f64 (/.f64 re im) re)
(/.f64 re im)
Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im))
(*.f64 (/.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im)) (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (neg.f64 im) im) im))) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (fma.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) #s(literal 1/2 binary64) (*.f64 im im))))
(*.f64 (/.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im)) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (neg.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 im im)))))) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (neg.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 im im)))))
(*.f64 (/.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im)) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (*.f64 (*.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 im im)) (fma.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 im im))) (fma.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 im im))))) (fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))) #s(literal 1/16 binary64) (*.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 im im)) (-.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 im im)) (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64))))))
(*.f64 (/.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im)) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im))
(*.f64 (fma.f64 im im (*.f64 #s(literal -1/4 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (-.f64 im (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)))))
(*.f64 (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im))) (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im)))
(*.f64 (neg.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(*.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)))))
(*.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im)) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(*.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im))
(*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)) (/.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im))))
(*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)) (*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)))))
(*.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (/.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(pow.f64 (/.f64 (-.f64 im (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re))) (fma.f64 im im (*.f64 #s(literal -1/4 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)) #s(literal -1 binary64))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))) #s(literal 1/16 binary64) (*.f64 (*.f64 (*.f64 (neg.f64 im) im) im) im)) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 im im)))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (*.f64 (neg.f64 (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))) (fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))) #s(literal 1/16 binary64) (fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) #s(literal 1 binary64))) (*.f64 (*.f64 (*.f64 im im) im) im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (*.f64 (neg.f64 (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)))) (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (neg.f64 im) im) im)))
(/.f64 (*.f64 (fma.f64 #s(literal 1/512 binary64) (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 9 binary64)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) #s(literal 1 binary64))) (*.f64 (*.f64 re re) #s(literal 1 binary64)))))))
(/.f64 (*.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im)) #s(literal 1 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))) (*.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))))) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))) (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))))) (fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (fma.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (*.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))))
(/.f64 (neg.f64 (fma.f64 im im (*.f64 #s(literal -1/4 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))))) (neg.f64 (-.f64 im (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im)))) (neg.f64 (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im)))) (neg.f64 (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))) #s(literal 1/16 binary64) (*.f64 (*.f64 (*.f64 (neg.f64 im) im) im) im)) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 im im)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (*.f64 (neg.f64 (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))) #s(literal 1/16 binary64) (fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) #s(literal 1 binary64))) (*.f64 (*.f64 (*.f64 im im) im) im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (*.f64 (neg.f64 (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) #s(literal 1 binary64)) (*.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (neg.f64 im) im) im)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im))))
(/.f64 (*.f64 (fma.f64 #s(literal 1/512 binary64) (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 9 binary64)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) #s(literal 1 binary64))) (*.f64 (*.f64 re re) #s(literal 1 binary64)))))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im))) (*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))
(/.f64 (fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))) #s(literal 1/16 binary64) (*.f64 (*.f64 (*.f64 (neg.f64 im) im) im) im)) (*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 im im))))
(/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (*.f64 (neg.f64 (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))) #s(literal 1/16 binary64) (fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) #s(literal 1 binary64))) (*.f64 (*.f64 (*.f64 im im) im) im)))))
(/.f64 (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (*.f64 (neg.f64 (*.f64 (*.f64 im im) im)) (*.f64 (*.f64 im im) im))) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)) (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (neg.f64 im) im) im))))
(/.f64 (fma.f64 im im (*.f64 #s(literal -1/4 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)))) (-.f64 im (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re))))
(/.f64 (fma.f64 #s(literal 1/512 binary64) (pow.f64 (*.f64 (/.f64 re im) re) #s(literal 9 binary64)) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)))) (*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)) (fma.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im)))) #s(literal 1/64 binary64) (-.f64 (*.f64 (*.f64 (*.f64 im im) im) (*.f64 (*.f64 im im) im)) (*.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (*.f64 (*.f64 re re) #s(literal 1 binary64))) (*.f64 (*.f64 re re) #s(literal 1 binary64))))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im))) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im))) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im))))
(/.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 im (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re))) (fma.f64 im im (*.f64 #s(literal -1/4 binary64) (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im))))
(neg.f64 (/.f64 (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im)) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(neg.f64 (/.f64 (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 im im) im)) (neg.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64)) (fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 (*.f64 re re) re) (/.f64 (*.f64 (*.f64 re re) re) (*.f64 (*.f64 im im) im))) (*.f64 (*.f64 (neg.f64 im) im) im))) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (fma.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) #s(literal 1/2 binary64) (*.f64 im im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 (/.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64)) (fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64) (*.f64 (neg.f64 im) im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) re) #s(literal 1 binary64)) (/.f64 re im) im)
(fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) re) (neg.f64 im)) (neg.f64 re) im)
(fma.f64 (sqrt.f64 im) (sqrt.f64 im) (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)))
(fma.f64 (/.f64 (neg.f64 re) #s(literal -1 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
(fma.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re im) im)
(fma.f64 (*.f64 (*.f64 (neg.f64 re) re) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) im) im)
(fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) re)) (/.f64 (*.f64 (/.f64 re im) re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) re im)
(fma.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 re re) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/2 binary64) re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 re re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 #s(literal -1 binary64) (neg.f64 im) (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)))
(fma.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 #s(literal 1 binary64) re)) im)
(fma.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(fma.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) im)
(fma.f64 #s(literal 1 binary64) im (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)))
(fma.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64)) (/.f64 #s(literal -1 binary64) (fma.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 re im) re) im)) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 (neg.f64 re) (/.f64 (*.f64 #s(literal 1/2 binary64) re) (neg.f64 im)) im)
(fma.f64 (neg.f64 re) (*.f64 (/.f64 #s(literal -1 binary64) im) (*.f64 #s(literal 1/2 binary64) re)) im)
(fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/2 binary64)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)
(fma.f64 (*.f64 (/.f64 re im) re) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)
(fma.f64 (/.f64 re im) (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (/.f64 re im) re)) re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(fma.f64 (/.f64 re im) (*.f64 #s(literal 1/2 binary64) re) im)
(fma.f64 im #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 (*.f64 re re) (*.f64 (/.f64 #s(literal 1 binary64) im) #s(literal 1/2 binary64)) im)
(fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
(-.f64 (/.f64 (*.f64 im im) (-.f64 im (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)))) (/.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) #s(literal 1/4 binary64)) (-.f64 im (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)))))
(-.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im))) #s(literal -1 binary64)))
(+.f64 (*.f64 (*.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im)))) (neg.f64 (*.f64 im (/.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) (neg.f64 im))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)) im)
(+.f64 im (*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re)))
(*.f64 (/.f64 re #s(literal 1 binary64)) (/.f64 re im))
(*.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 (neg.f64 re) im))
(*.f64 (/.f64 (neg.f64 re) #s(literal -1 binary64)) (/.f64 re im))
(*.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) im))
(*.f64 (/.f64 (neg.f64 re) im) (neg.f64 re))
(*.f64 (*.f64 (neg.f64 re) re) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 re re))
(*.f64 #s(literal 1 binary64) (*.f64 (/.f64 re im) re))
(*.f64 (neg.f64 re) (*.f64 (/.f64 #s(literal -1 binary64) im) re))
(*.f64 (neg.f64 re) (/.f64 (neg.f64 re) im))
(*.f64 (/.f64 re im) re)
(*.f64 (*.f64 re re) (/.f64 #s(literal 1 binary64) im))
(*.f64 re (/.f64 re im))
(pow.f64 (/.f64 (/.f64 im (*.f64 re re)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 im (*.f64 re re)) #s(literal -1 binary64))
(/.f64 (/.f64 (*.f64 (neg.f64 re) re) #s(literal -1 binary64)) im)
(/.f64 (*.f64 (*.f64 re re) #s(literal -1 binary64)) (neg.f64 im))
(/.f64 (neg.f64 (*.f64 (neg.f64 re) re)) im)
(/.f64 (*.f64 (*.f64 re re) #s(literal 1 binary64)) im)
(/.f64 (*.f64 (neg.f64 re) re) (neg.f64 im))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im (*.f64 re re)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 im (*.f64 re re)))
(/.f64 (neg.f64 re) (/.f64 (neg.f64 im) re))
(/.f64 (/.f64 re im) (/.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 re re) im)
(/.f64 re (/.f64 im re))
(neg.f64 (/.f64 (*.f64 (neg.f64 re) re) im))
(neg.f64 (/.f64 (*.f64 re re) (neg.f64 im)))
(neg.f64 (*.f64 re (/.f64 (neg.f64 re) im)))
(neg.f64 (*.f64 (/.f64 (neg.f64 re) im) re))
(exp.f64 (fma.f64 (log.f64 im) #s(literal -1 binary64) (*.f64 (log.f64 re) #s(literal 2 binary64))))
(exp.f64 (fma.f64 (log.f64 (/.f64 im re)) #s(literal -1 binary64) (*.f64 (log.f64 re) #s(literal 1 binary64))))
(exp.f64 (fma.f64 (log.f64 re) #s(literal 2 binary64) (*.f64 (log.f64 im) #s(literal -1 binary64))))
(exp.f64 (fma.f64 (log.f64 re) #s(literal 1 binary64) (*.f64 (log.f64 (/.f64 im re)) #s(literal -1 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 im (*.f64 re re))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 im re) #s(literal -1/2 binary64)) (pow.f64 (/.f64 im re) #s(literal -1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 #s(literal -1 binary64) im) (neg.f64 re))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 re) im))
(*.f64 (/.f64 #s(literal 1 binary64) im) re)
(*.f64 #s(literal 1 binary64) (/.f64 re im))
(*.f64 (neg.f64 re) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 re im) #s(literal 1 binary64))
(*.f64 re (/.f64 #s(literal 1 binary64) im))
(pow.f64 (pow.f64 (/.f64 im re) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 im re) #s(literal -1 binary64))
(pow.f64 (/.f64 re im) #s(literal 1 binary64))
(/.f64 (/.f64 (neg.f64 re) #s(literal -1 binary64)) im)
(/.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 im))
(/.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(/.f64 #s(literal -1 binary64) (/.f64 (neg.f64 im) re))
(/.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 1 binary64) re))
(/.f64 #s(literal 1 binary64) (/.f64 im re))
(/.f64 (neg.f64 re) (neg.f64 im))
(/.f64 re im)
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 im re)))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (neg.f64 re) im)))
(neg.f64 (/.f64 (neg.f64 re) im))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 im)) (/.f64 (neg.f64 re) im))
(-.f64 #s(literal 0 binary64) (/.f64 (neg.f64 re) im))
(exp.f64 (fma.f64 (log.f64 im) #s(literal -1 binary64) (*.f64 (log.f64 re) #s(literal 1 binary64))))
(exp.f64 (fma.f64 (log.f64 re) #s(literal 1 binary64) (*.f64 (log.f64 im) #s(literal -1 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 im re)) #s(literal -1 binary64)))

eval33.0ms (0.8%)

Memory
-13.5MiB live, 71.2MiB allocated
Compiler

Compiled 5 770 to 526 computations (90.9% saved)

prune58.0ms (1.4%)

Memory
23.9MiB live, 63.1MiB allocated
Pruning

5 alts after pruning (0 fresh and 5 done)

PrunedKeptTotal
New2470247
Fresh000
Picked011
Done044
Total2475252
Accuracy
100.0%
Counts
252 → 5
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓50.2%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
✓4.5%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
✓49.8%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
✓99.8%
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
✓1.7%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Compiler

Compiled 99 to 43 computations (56.6% saved)

regimes37.0ms (0.9%)

Memory
-4.9MiB live, 34.1MiB allocated
Counts
9 → 1
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
(hypot.f64 re im)
Outputs
(hypot.f64 re im)
Calls

6 calls:

20.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
3.0ms
im
3.0ms
re
3.0ms
(*.f64 im im)
3.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Results
AccuracySegmentsBranch
100.0%1re
100.0%1im
100.0%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
100.0%1(+.f64 (*.f64 re re) (*.f64 im im))
100.0%1(*.f64 re re)
100.0%1(*.f64 im im)
Compiler

Compiled 35 to 21 computations (40% saved)

regimes21.0ms (0.5%)

Memory
-0.4MiB live, 36.7MiB allocated
Counts
8 → 1
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
Calls

6 calls:

6.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
3.0ms
re
3.0ms
im
3.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
3.0ms
(*.f64 im im)
Results
AccuracySegmentsBranch
99.8%1re
99.8%1im
99.8%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
99.8%1(+.f64 (*.f64 re re) (*.f64 im im))
99.8%1(*.f64 re re)
99.8%1(*.f64 im im)
Compiler

Compiled 35 to 21 computations (40% saved)

regimes44.0ms (1%)

Memory
-22.8MiB live, 21.6MiB allocated
Counts
5 → 1
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 im re) re))
Outputs
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
Calls

6 calls:

33.0ms
re
2.0ms
im
2.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
2.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
2.0ms
(*.f64 im im)
Results
AccuracySegmentsBranch
50.2%1re
50.2%1im
50.2%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
50.2%1(+.f64 (*.f64 re re) (*.f64 im im))
50.2%1(*.f64 re re)
50.2%1(*.f64 im im)
Compiler

Compiled 35 to 21 computations (40% saved)

regimes11.0ms (0.3%)

Memory
19.4MiB live, 19.4MiB allocated
Counts
3 → 1
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
Outputs
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
Calls

6 calls:

2.0ms
im
2.0ms
re
2.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
2.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
2.0ms
(*.f64 im im)
Results
AccuracySegmentsBranch
49.8%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
49.8%1(+.f64 (*.f64 re re) (*.f64 im im))
49.8%1(*.f64 im im)
49.8%1im
49.8%1re
49.8%1(*.f64 re re)
Compiler

Compiled 35 to 21 computations (40% saved)

regimes8.0ms (0.2%)

Memory
18.4MiB live, 18.4MiB allocated
Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts
1 → 1
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Calls

6 calls:

1.0ms
im
1.0ms
re
1.0ms
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
1.0ms
(*.f64 im im)
1.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
Results
AccuracySegmentsBranch
1.7%1(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
1.7%1(+.f64 (*.f64 re re) (*.f64 im im))
1.7%1(*.f64 im im)
1.7%1re
1.7%1im
1.7%1(*.f64 re re)
Compiler

Compiled 35 to 21 computations (40% saved)

simplify8.0ms (0.2%)

Memory
-23.2MiB live, 14.1MiB allocated
Algorithm
1×egg-herbie
Rules
4×*-commutative_binary64
2×+-commutative_binary64
2×sub-neg_binary64
2×neg-sub0_binary64
2×neg-mul-1_binary64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01950
12450
22650
32750
Stop Event
1×saturated
Calls
Call 1
Inputs
(hypot.f64 re im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Outputs
(hypot.f64 re im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

soundness824.0ms (19.5%)

Memory
-8.1MiB live, 471.2MiB allocated
Rules
18 004×lower-fma.f64
18 004×lower-fma.f32
9 152×lower-fma.f32
9 148×lower-fma.f64
5 720×lower-fma.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01562
02362
19162
264762
0818252
0621
01021
12921
219621
3178821
0862415
0104620
1296620
2953618
33667584
46426582
08051530
Stop Event
1×done
1×iter limit
1×node limit
1×iter limit
1×node limit
1×iter limit
1×iter limit
1×node limit
1×iter limit
Compiler

Compiled 90 to 46 computations (48.9% saved)

preprocess61.0ms (1.4%)

Memory
31.3MiB live, 69.4MiB allocated
Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 108 to 54 computations (50% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...