math.abs on complex

Time bar (total: 5.5s)

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)

sample640.0ms (11.5%)

Memory
20.3MiB live, 649.2MiB allocated
Samples
427.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 204.0ms
ival-hypot: 195.0ms (95.4% of total)
ival-true: 6.0ms (2.9% of total)
ival-assert: 3.0ms (1.5% of total)
Bogosity

preprocess44.0ms (0.8%)

Memory
-14.7MiB live, 23.7MiB 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 re re (*.f64 im im)))
Symmetry

(abs im)

(abs re)

(sort re im)

explain88.0ms (1.6%)

Memory
20.2MiB live, 98.3MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1380-3(3.974323565759146e-169 5.0619523332457585e-157)(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-rescue1180
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow118
↳(*.f64 re re)overflow20
↳(*.f64 im im)overflow118
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue170
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow17
↳(*.f64 re re)underflow110
↳(*.f64 im im)underflow17
Confusion
Predicted +Predicted -
+1353
-0118
Precision
1.0
Recall
0.9782608695652174
Confusion?
Predicted +Predicted MaybePredicted -
+13503
-00118
Precision?
1.0
Recall?
0.9782608695652174
Freqs
test
numberfreq
0121
1135
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
30.0ms512×0valid
Compiler

Compiled 70 to 28 computations (60% saved)

Precisions
Click to see histograms. Total time spent on operations: 17.0ms
ival-hypot: 8.0ms (46.4% of total)
ival-mult: 6.0ms (34.8% of total)
ival-add: 2.0ms (11.6% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.2MiB live, 0.2MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

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

Compiled 10 to 6 computations (40% saved)

simplify4.0ms (0.1%)

Memory
2.8MiB live, 2.8MiB 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 re re (*.f64 im im)))
(+.f64 (*.f64 re re) (*.f64 im im))
(fma.f64 re re (*.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im

localize59.0ms (1.1%)

Memory
-22.2MiB live, 20.6MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(+.f64 (*.f64 re re) (*.f64 im im))
✓accuracy100.0%
(*.f64 re re)
✓accuracy100.0%
(*.f64 im im)
✓accuracy50.6%
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Samples
51.0ms256×0valid
Compiler

Compiled 25 to 8 computations (68% saved)

Precisions
Click to see histograms. Total time spent on operations: 45.0ms
ival-hypot: 41.0ms (91.2% of total)
ival-mult: 3.0ms (6.7% of total)
ival-add: 1.0ms (2.2% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series5.0ms (0.1%)

Memory
7.5MiB live, 7.5MiB 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 (pow re 2) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (*.f64 re re) (*.f64 im im)) (patch (+.f64 (*.f64 re re) (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) (patch (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (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 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 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

18 calls:

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

rewrite525.0ms (9.5%)

Memory
8.9MiB live, 375.1MiB allocated
Algorithm
1×batch-egg-rewrite
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 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))
(exp.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (/.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (/.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 re (+.f64 re im)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 re im)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 re im)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 im im (*.f64 re re)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (fma.f64 im im (*.f64 re re))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 im im (*.f64 re re))))
(/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 #s(literal 1 binary64) (/.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) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 re im) (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))
(/.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (-.f64 re im))
(/.f64 (exp.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (exp.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (exp.f64 (log.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (exp.f64 (log.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (exp.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (exp.f64 (log.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))) (exp.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im))))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) #s(literal 1 binary64))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 re im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1 binary64))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (-.f64 re im)) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1 binary64))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 re im)) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (-.f64 re im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 re im) #s(literal 1 binary64))) (*.f64 (-.f64 re im) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (-.f64 re im) (neg.f64 (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (-.f64 re im) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (-.f64 re im)) (*.f64 (-.f64 re im) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (-.f64 re im) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (neg.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (neg.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (neg.f64 (-.f64 re im)))
(/.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (pow.f64 (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 (*.f64 (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64))
(*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 im im (*.f64 re re)))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)))))
(*.f64 (pow.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(*.f64 (exp.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (exp.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(*.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (neg.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(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 (*.f64 (fma.f64 im im (*.f64 re re)) (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 (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))))
(hypot.f64 re im)
(hypot.f64 im re)
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))) (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 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 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(*.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 re im)))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re))))))
(*.f64 (pow.f64 (pow.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 (+.f64 re im) (-.f64 re im)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re))))))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 re)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 re)) #s(literal 1 binary64)))
(pow.f64 re #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 re))
(*.f64 re re)
(exp.f64 (log.f64 (*.f64 im im)))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal 1 binary64)))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 im))
(*.f64 im im)

simplify645.0ms (11.6%)

Memory
-10.5MiB live, 471.5MiB 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
2956618
33681584
46441582
08069530
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))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 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 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.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 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) re)) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (/.f64 (*.f64 im (*.f64 im (*.f64 (*.f64 im im) #s(literal -1/8 binary64)))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) re)) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) re)) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -1/2 binary64) (*.f64 im (/.f64 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 re (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1 binary64)) (*.f64 #s(literal -1/2 binary64) (*.f64 im (/.f64 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 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1 binary64))) re (*.f64 #s(literal -1/2 binary64) (*.f64 im (/.f64 im re))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) re)) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im (/.f64 im re)) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/8 binary64) (*.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 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 im (*.f64 (/.f64 im (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64)) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal -1 binary64)) (*.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 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 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal -1 binary64))) im (*.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 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)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow 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)
(*.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)
(*.f64 im im)
(pow im 2)
(*.f64 im im)

eval89.0ms (1.6%)

Memory
5.4MiB live, 79.6MiB allocated
Compiler

Compiled 14 149 to 959 computations (93.2% saved)

prune104.0ms (1.9%)

Memory
-20.5MiB live, 99.8MiB allocated
Pruning

6 alts after pruning (6 fresh and 0 done)

PrunedKeptTotal
New3076313
Fresh000
Picked101
Done000
Total3086314
Accuracy
100.0%
Counts
314 → 6
Alt Table
Click to see full alt table
StatusAccuracyProgram
99.9%
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
▶100.0%
(hypot.f64 re im)
▶50.6%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
▶4.5%
(sqrt.f64 (*.f64 re re))
▶50.4%
(sqrt.f64 (*.f64 im im))
▶1.8%
(neg.f64 re)
Compiler

Compiled 80 to 50 computations (37.5% saved)

simplify14.0ms (0.3%)

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

Found 9 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-diff832
(sqrt.f64 (*.f64 re re))
✓cost-diff0
(*.f64 im im)
✓cost-diff832
(sqrt.f64 (*.f64 im im))
✓cost-diff0
(neg.f64 re)
✓cost-diff5120
(hypot.f64 re im)
Rules
144×lower-fma.f32
142×lower-fma.f64
104×lower-*.f32
100×lower-*.f64
48×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01038
01734
12434
22634
32834
43034
53434
64434
75634
87134
98334
1011934
1113334
1215034
1317034
1420034
1523234
1624934
1724934
024934
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
(hypot.f64 re im)
re
im
(neg.f64 re)
re
(sqrt.f64 (*.f64 im im))
(*.f64 im im)
im
(sqrt.f64 (*.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 re re (*.f64 im im)))
re
im
(neg.f64 re)
re
(sqrt.f64 (*.f64 im im))
(fabs.f64 im)
(*.f64 im im)
im
(sqrt.f64 (*.f64 re re))
(fabs.f64 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

localize54.0ms (1%)

Memory
-21.5MiB live, 60.1MiB allocated
Localize:

Found 9 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(fma.f64 re re (*.f64 im im))
✓accuracy100.0%
(*.f64 im im)
✓accuracy50.6%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
✓accuracy100.0%
(*.f64 re re)
✓accuracy52.3%
(sqrt.f64 (*.f64 re re))
✓accuracy100.0%
(*.f64 im im)
✓accuracy50.6%
(sqrt.f64 (*.f64 im im))
✓accuracy100.0%
(neg.f64 re)
✓accuracy100.0%
(hypot.f64 re im)
Samples
30.0ms256×0valid
Compiler

Compiled 51 to 11 computations (78.4% saved)

Precisions
Click to see histograms. Total time spent on operations: 21.0ms
ival-hypot: 12.0ms (57.9% of total)
ival-mult: 3.0ms (14.5% of total)
ival-sqrt: 3.0ms (14.5% of total)
ival-add: 1.0ms (4.8% of total)
ival-neg: 1.0ms (4.8% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series4.0ms (0.1%)

Memory
5.8MiB live, 5.8MiB allocated
Counts
8 → 132
Calls
Call 1
Inputs
#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())
#s(alt (neg.f64 re) (patch (neg.f64 re) #<representation binary64>) () ())
#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())
#s(alt (*.f64 im im) (patch (*.f64 im im) #<representation binary64>) () ())
#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.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 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 (* -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 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 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 (* -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 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 (* -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 (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 im (taylor 0 im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (*.f64 im im)) (patch (sqrt.f64 (*.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 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 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 re (taylor 0 re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (*.f64 re re)) (patch (sqrt.f64 (*.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 (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (*.f64 re re) (patch (*.f64 re re) #<representation binary64>) () ())) ())
#s(alt 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 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 (* -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 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 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 (* -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 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 (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 (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 (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 (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 (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

33 calls:

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

rewrite667.0ms (12%)

Memory
-8.3MiB live, 355.1MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
4 452×lower-fma.f32
4 450×lower-fma.f64
3 446×lower-*.f32
3 442×lower-*.f64
2 114×lower-/.f64
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
01028
01724
14822
224222
3218022
0857022
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
8 → 686
Calls
Call 1
Inputs
(hypot.f64 re im)
(neg.f64 re)
(sqrt.f64 (*.f64 im im))
(*.f64 im im)
(sqrt.f64 (*.f64 re re))
(*.f64 re re)
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
Outputs
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (fma.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))))
(hypot.f64 re im)
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 im re)
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (-.f64 re #s(literal 0 binary64)))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (-.f64 re #s(literal 0 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (-.f64 re #s(literal 0 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (-.f64 re #s(literal 0 binary64)) im)
(hypot.f64 (-.f64 re #s(literal 0 binary64)) (neg.f64 im))
(hypot.f64 (-.f64 re #s(literal 0 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (-.f64 re #s(literal 0 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (-.f64 re #s(literal 0 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (-.f64 re #s(literal 0 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) re)
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (-.f64 re #s(literal 0 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) im)
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1 binary64))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (pow.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (pow.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 re im)))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (pow.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (pow.f64 (pow.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 (+.f64 re im) (-.f64 re im)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(+.f64 (neg.f64 re) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (neg.f64 re))
(-.f64 #s(literal 0 binary64) re)
(-.f64 (/.f64 #s(literal 0 binary64) (*.f64 re re)) re)
(-.f64 (/.f64 #s(literal 0 binary64) re) re)
(fma.f64 re #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 re) (neg.f64 (sqrt.f64 re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 re) #s(literal -1 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) re #s(literal 0 binary64))
(fma.f64 (neg.f64 (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (*.f64 re re)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (neg.f64 (sqrt.f64 re)) (sqrt.f64 re) #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal -1 binary64) (sqrt.f64 re)) (sqrt.f64 re) #s(literal 0 binary64))
(neg.f64 re)
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 re re) (neg.f64 (*.f64 re (*.f64 re re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 re (neg.f64 (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (neg.f64 (*.f64 re (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 re (neg.f64 (*.f64 re re))))
(/.f64 (neg.f64 (*.f64 re (*.f64 re re))) (*.f64 re re))
(/.f64 (neg.f64 (*.f64 re (*.f64 re re))) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 #s(literal 0 binary64) (neg.f64 re)))))
(/.f64 (neg.f64 (*.f64 re re)) re)
(/.f64 (neg.f64 (*.f64 re re)) (-.f64 #s(literal 0 binary64) (neg.f64 re)))
(/.f64 (neg.f64 (neg.f64 (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 re re)))
(/.f64 (neg.f64 (neg.f64 (*.f64 re (*.f64 re re)))) (neg.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 #s(literal 0 binary64) (neg.f64 re))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 re re))) (neg.f64 re))
(/.f64 (neg.f64 (neg.f64 (*.f64 re re))) (neg.f64 (-.f64 #s(literal 0 binary64) (neg.f64 re))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re re))))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (neg.f64 re)) (*.f64 re (neg.f64 (*.f64 re re)))) (neg.f64 (*.f64 re re)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) #s(literal 0 binary64)))) (*.f64 re (+.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re))))) (*.f64 re (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (*.f64 re (*.f64 re re))))) (neg.f64 (neg.f64 (*.f64 re re))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (*.f64 re re)))) (neg.f64 (neg.f64 re)))
(pow.f64 (/.f64 (*.f64 re re) (neg.f64 (*.f64 re (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (/.f64 re (neg.f64 (*.f64 re re))) #s(literal -1 binary64))
(*.f64 re #s(literal -1 binary64))
(*.f64 (sqrt.f64 re) (neg.f64 (sqrt.f64 re)))
(*.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 re) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) re)
(*.f64 (neg.f64 (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re)))
(*.f64 (neg.f64 (*.f64 re re)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (neg.f64 (sqrt.f64 re)) (sqrt.f64 re))
(*.f64 (*.f64 #s(literal -1 binary64) (sqrt.f64 re)) (sqrt.f64 re))
im
(exp.f64 (log.f64 im))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 4 binary64)) #s(literal 1/4 binary64)))
(fabs.f64 im)
(fabs.f64 (neg.f64 im))
(fabs.f64 (neg.f64 (neg.f64 im)))
(fabs.f64 (neg.f64 (neg.f64 (neg.f64 im))))
(fabs.f64 (-.f64 im #s(literal 0 binary64)))
(sqrt.f64 (*.f64 im im))
(pow.f64 im #s(literal 1 binary64))
(pow.f64 (*.f64 im im) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im (*.f64 im (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (log.f64 im)))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 im))
(*.f64 (sqrt.f64 im) (sqrt.f64 im))
(*.f64 #s(literal 1 binary64) im)
(*.f64 (sqrt.f64 (sqrt.f64 im)) (pow.f64 (*.f64 im (sqrt.f64 im)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (pow.f64 (*.f64 im (*.f64 im im)) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 (*.f64 im (sqrt.f64 im))))
(*.f64 (pow.f64 (*.f64 im (sqrt.f64 im)) #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (pow.f64 (neg.f64 im) #s(literal 1/2 binary64)) (pow.f64 (neg.f64 im) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (*.f64 im (*.f64 im im)) #s(literal 1/4 binary64)) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (pow.f64 (sqrt.f64 im) #s(literal 1/4 binary64)) (pow.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im))) #s(literal 1/4 binary64)))
(*.f64 (pow.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im))) #s(literal 1/4 binary64)) (pow.f64 (sqrt.f64 im) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (*.f64 im (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (sqrt.f64 (neg.f64 im)) (sqrt.f64 (neg.f64 im)))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 4 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 4 binary64)))
(fabs.f64 (*.f64 im im))
(fabs.f64 (*.f64 im (neg.f64 im)))
(fabs.f64 (neg.f64 (*.f64 im (neg.f64 im))))
(fabs.f64 (*.f64 im (neg.f64 (neg.f64 im))))
(fabs.f64 (*.f64 (neg.f64 im) (neg.f64 (neg.f64 im))))
(fabs.f64 (*.f64 (neg.f64 (neg.f64 im)) im))
(fabs.f64 (*.f64 (neg.f64 (neg.f64 im)) (neg.f64 im)))
(fabs.f64 (-.f64 (*.f64 im im) #s(literal 0 binary64)))
(sqrt.f64 (*.f64 im (*.f64 im (*.f64 im im))))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 im) #s(literal 4 binary64))
(pow.f64 (*.f64 im (*.f64 im (*.f64 im im))) #s(literal 1/2 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 im))
(*.f64 im im)
(*.f64 (sqrt.f64 im) (*.f64 im (sqrt.f64 im)))
(*.f64 #s(literal 1 binary64) (*.f64 im im))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (pow.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im)))))
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (*.f64 im (sqrt.f64 im)) (sqrt.f64 im))
(*.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(*.f64 (pow.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im))) #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (sqrt.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im)))) (sqrt.f64 (sqrt.f64 im)))
re
(+.f64 re #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) re)
(exp.f64 (log.f64 re))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal 4 binary64)) #s(literal 1/4 binary64)))
(exp.f64 (-.f64 (*.f64 (log.f64 (*.f64 re re)) #s(literal 3/2 binary64)) (log.f64 (*.f64 re re))))
(exp.f64 (-.f64 (*.f64 (log.f64 re) #s(literal 3 binary64)) (log.f64 (*.f64 re re))))
(fabs.f64 re)
(fabs.f64 (neg.f64 re))
(fabs.f64 (neg.f64 (neg.f64 re)))
(fabs.f64 (-.f64 re #s(literal 0 binary64)))
(fabs.f64 (neg.f64 (neg.f64 (neg.f64 re))))
(fabs.f64 (neg.f64 (-.f64 re #s(literal 0 binary64))))
(fabs.f64 (/.f64 (*.f64 re re) (neg.f64 re)))
(fabs.f64 (/.f64 (*.f64 re re) (neg.f64 (neg.f64 re))))
(fabs.f64 (/.f64 (*.f64 re re) (-.f64 re #s(literal 0 binary64))))
(fabs.f64 (/.f64 (neg.f64 (*.f64 re re)) (neg.f64 (neg.f64 re))))
(fabs.f64 (/.f64 (neg.f64 (*.f64 re re)) (-.f64 re #s(literal 0 binary64))))
(fabs.f64 (-.f64 re (/.f64 #s(literal 0 binary64) (*.f64 re re))))
(fabs.f64 (-.f64 re (/.f64 #s(literal 0 binary64) re)))
(sqrt.f64 (*.f64 re re))
(sqrt.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re re)))
(fma.f64 re #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (*.f64 re re) (fabs.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 re) (sqrt.f64 re) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 re) (fabs.f64 (*.f64 (sqrt.f64 re) #s(literal -1 binary64))) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) re #s(literal 0 binary64))
(fma.f64 (*.f64 re (*.f64 re re)) (fabs.f64 (/.f64 #s(literal 1 binary64) (*.f64 re re))) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (sqrt.f64 re)) (pow.f64 (*.f64 re (sqrt.f64 re)) #s(literal 1/2 binary64)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (sqrt.f64 re)) (pow.f64 (*.f64 re (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (sqrt.f64 re)) (sqrt.f64 (*.f64 re (sqrt.f64 re))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 re) #s(literal 1/2 binary64)) (pow.f64 (neg.f64 re) #s(literal 1/2 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (*.f64 re (sqrt.f64 re)) #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 re)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (*.f64 re (*.f64 re re)) #s(literal 1/4 binary64)) (sqrt.f64 (sqrt.f64 re)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (sqrt.f64 re) #s(literal 1/4 binary64)) (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (pow.f64 (sqrt.f64 re) #s(literal 1/4 binary64)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (neg.f64 re)) (sqrt.f64 (neg.f64 re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (*.f64 re (sqrt.f64 re))) (sqrt.f64 (sqrt.f64 re)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (*.f64 #s(literal -1 binary64) (sqrt.f64 re))) (sqrt.f64 re) #s(literal 0 binary64))
(/.f64 (*.f64 re re) re)
(/.f64 (*.f64 re re) (fabs.f64 (-.f64 #s(literal 0 binary64) (neg.f64 re))))
(/.f64 #s(literal 1 binary64) (fabs.f64 (/.f64 (*.f64 re re) (neg.f64 (*.f64 re (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (fabs.f64 (/.f64 re (neg.f64 (*.f64 re re)))))
(/.f64 (*.f64 re (*.f64 re re)) (*.f64 re re))
(/.f64 (*.f64 re (*.f64 re re)) (fabs.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) (*.f64 #s(literal 0 binary64) (neg.f64 re))))))
(/.f64 (neg.f64 (*.f64 re (*.f64 re re))) (neg.f64 (*.f64 re re)))
(/.f64 (neg.f64 (*.f64 re re)) (neg.f64 re))
(/.f64 (neg.f64 (neg.f64 (*.f64 re re))) (neg.f64 (neg.f64 re)))
(/.f64 (+.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re))) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) #s(literal 0 binary64))))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 0 binary64))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 re re) #s(literal 0 binary64))))))
(/.f64 (sqrt.f64 (+.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 #s(literal 0 binary64) (*.f64 re re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 0 binary64))) (sqrt.f64 (-.f64 (*.f64 re re) #s(literal 0 binary64))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (neg.f64 (*.f64 re re))))
(/.f64 (fabs.f64 (+.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re)))) (fabs.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (+.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re re)))) (neg.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re re) #s(literal 0 binary64)))))
(pow.f64 re #s(literal 1 binary64))
(pow.f64 (*.f64 re re) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 re re)))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 re)))
(pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 re))
(*.f64 re #s(literal 1 binary64))
(*.f64 (*.f64 re re) (fabs.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 re) (sqrt.f64 re))
(*.f64 (sqrt.f64 re) (fabs.f64 (*.f64 (sqrt.f64 re) #s(literal -1 binary64))))
(*.f64 #s(literal 1 binary64) re)
(*.f64 (*.f64 re (*.f64 re re)) (fabs.f64 (/.f64 #s(literal 1 binary64) (*.f64 re re))))
(*.f64 (sqrt.f64 (sqrt.f64 re)) (pow.f64 (*.f64 re (sqrt.f64 re)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 re)) (pow.f64 (*.f64 re (*.f64 re re)) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 re)) (sqrt.f64 (*.f64 re (sqrt.f64 re))))
(*.f64 (pow.f64 (neg.f64 re) #s(literal 1/2 binary64)) (pow.f64 (neg.f64 re) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (*.f64 re (sqrt.f64 re)) #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 re)))
(*.f64 (pow.f64 (*.f64 re (*.f64 re re)) #s(literal 1/4 binary64)) (sqrt.f64 (sqrt.f64 re)))
(*.f64 (pow.f64 (sqrt.f64 re) #s(literal 1/4 binary64)) (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)))
(*.f64 (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (pow.f64 (sqrt.f64 re) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (neg.f64 re)) (sqrt.f64 (neg.f64 re)))
(*.f64 (sqrt.f64 (*.f64 re (sqrt.f64 re))) (sqrt.f64 (sqrt.f64 re)))
(*.f64 (fabs.f64 (*.f64 #s(literal -1 binary64) (sqrt.f64 re))) (sqrt.f64 re))
(+.f64 (*.f64 re re) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 re re))
(exp.f64 (log.f64 (*.f64 re re)))
(exp.f64 (*.f64 (log.f64 (*.f64 re re)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal 4 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 re)) #s(literal 4 binary64)))
(fabs.f64 (*.f64 re re))
(fabs.f64 (neg.f64 (*.f64 re re)))
(fabs.f64 (neg.f64 (neg.f64 (*.f64 re re))))
(fabs.f64 (-.f64 (*.f64 re re) #s(literal 0 binary64)))
(fabs.f64 (*.f64 re (neg.f64 (neg.f64 re))))
(fabs.f64 (*.f64 re (-.f64 re #s(literal 0 binary64))))
(fabs.f64 (*.f64 (neg.f64 re) (neg.f64 (neg.f64 re))))
(fabs.f64 (*.f64 (neg.f64 re) (-.f64 re #s(literal 0 binary64))))
(fabs.f64 (*.f64 (neg.f64 (neg.f64 re)) re))
(fabs.f64 (*.f64 (neg.f64 (neg.f64 re)) (neg.f64 re)))
(fabs.f64 (*.f64 (neg.f64 (neg.f64 re)) (-.f64 re #s(literal 0 binary64))))
(fabs.f64 (*.f64 (-.f64 re #s(literal 0 binary64)) re))
(fabs.f64 (*.f64 (-.f64 re #s(literal 0 binary64)) (neg.f64 re)))
(fabs.f64 (*.f64 (-.f64 re #s(literal 0 binary64)) (neg.f64 (neg.f64 re))))
(sqrt.f64 (*.f64 re (*.f64 re (*.f64 re re))))
(fma.f64 re re #s(literal 0 binary64))
(fma.f64 (neg.f64 re) (neg.f64 re) #s(literal 0 binary64))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 re) (*.f64 re (sqrt.f64 re)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) #s(literal 0 binary64))
(fma.f64 (*.f64 re (sqrt.f64 re)) (sqrt.f64 re) #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) #s(literal 0 binary64))
(fma.f64 (-.f64 re #s(literal 0 binary64)) (-.f64 re #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (sqrt.f64 re)) (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/2 binary64)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (sqrt.f64 re)) (sqrt.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re)))) #s(literal 0 binary64))
(fma.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re)))) (sqrt.f64 (sqrt.f64 re)) #s(literal 0 binary64))
(/.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 0 binary64)) (fma.f64 re (*.f64 re (*.f64 re re)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 re re) #s(literal 0 binary64)))))
(/.f64 (+.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 #s(literal 0 binary64) (*.f64 re re)))))
(/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 0 binary64)) (-.f64 (*.f64 re re) #s(literal 0 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 re re)))
(/.f64 (fabs.f64 (-.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (fabs.f64 (+.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 #s(literal 0 binary64) (*.f64 re re))))))
(/.f64 (fabs.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 0 binary64))) (fabs.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 re re) #s(literal 0 binary64))))))
(/.f64 (fabs.f64 (+.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (fabs.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 #s(literal 0 binary64) (*.f64 re re))))))
(/.f64 (fabs.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 0 binary64))) (*.f64 re re))
(/.f64 (fabs.f64 (-.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re re))
(/.f64 (neg.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 0 binary64))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 re re) #s(literal 0 binary64))))))
(/.f64 (neg.f64 (+.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 #s(literal 0 binary64) (*.f64 re re))))))
(/.f64 (neg.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 0 binary64))) (neg.f64 (-.f64 (*.f64 re re) #s(literal 0 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (neg.f64 (*.f64 re re))))
(pow.f64 re #s(literal 2 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 re) #s(literal 4 binary64))
(pow.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/2 binary64))
(pow.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 re))
(*.f64 re re)
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (*.f64 re re) #s(literal 1 binary64))
(*.f64 (sqrt.f64 re) (*.f64 re (sqrt.f64 re)))
(*.f64 #s(literal 1 binary64) (*.f64 re re))
(*.f64 (*.f64 re (sqrt.f64 re)) (sqrt.f64 re))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (-.f64 re #s(literal 0 binary64)) (-.f64 re #s(literal 0 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 re)) (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 re)) (sqrt.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re)))))
(*.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(*.f64 (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 re)))
(*.f64 (sqrt.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re)))) (sqrt.f64 (sqrt.f64 re)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (fma.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))))
(hypot.f64 re im)
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 re (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 im re)
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (-.f64 re #s(literal 0 binary64)))
(hypot.f64 im (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 im (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 re) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (-.f64 re #s(literal 0 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 im) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 re)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (-.f64 re #s(literal 0 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (neg.f64 (neg.f64 im)) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (-.f64 re #s(literal 0 binary64)) im)
(hypot.f64 (-.f64 re #s(literal 0 binary64)) (neg.f64 im))
(hypot.f64 (-.f64 re #s(literal 0 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (-.f64 re #s(literal 0 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (-.f64 re #s(literal 0 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (-.f64 re #s(literal 0 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) re)
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (neg.f64 re))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (neg.f64 (neg.f64 re)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (-.f64 re #s(literal 0 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) im)
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (neg.f64 im))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (neg.f64 (neg.f64 im)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)))
(hypot.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (hypot.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1 binary64))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (pow.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (pow.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (sqrt.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 re im)))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (pow.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (pow.f64 (pow.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 (+.f64 re im) (-.f64 re im)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(exp.f64 (log.f64 (fma.f64 re re (*.f64 im im))))
(exp.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) (*.f64 im im))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (sqrt.f64 im) (*.f64 im (sqrt.f64 im)) (*.f64 re re))
(fma.f64 (sqrt.f64 re) (*.f64 re (sqrt.f64 re)) (*.f64 im im))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 #s(literal 1 binary64) (*.f64 im im) (*.f64 re re))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) (*.f64 im im))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (sqrt.f64 (sqrt.f64 im)) (pow.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im))) #s(literal 1/2 binary64)) (*.f64 re re))
(fma.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im)))) (*.f64 re re))
(fma.f64 (*.f64 re (sqrt.f64 re)) (sqrt.f64 re) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (-.f64 re #s(literal 0 binary64)) (-.f64 re #s(literal 0 binary64)) (*.f64 im im))
(fma.f64 (/.f64 re (+.f64 re im)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 re im)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 re im)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 im (sqrt.f64 im)) (sqrt.f64 im) (*.f64 re re))
(fma.f64 (sqrt.f64 (sqrt.f64 re)) (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/2 binary64)) (*.f64 im im))
(fma.f64 (sqrt.f64 (sqrt.f64 re)) (sqrt.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re)))) (*.f64 im im))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re re (*.f64 im im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (pow.f64 (neg.f64 im) #s(literal 1 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64)) (*.f64 re re))
(fma.f64 (pow.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im))) #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 im)) (*.f64 re re))
(fma.f64 (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (pow.f64 (neg.f64 re) #s(literal 1 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 re)) #s(literal 4 binary64)) (*.f64 im im))
(fma.f64 (pow.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re))) #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 re)) (*.f64 im im))
(fma.f64 (sqrt.f64 (*.f64 (sqrt.f64 im) (*.f64 im (*.f64 im im)))) (sqrt.f64 (sqrt.f64 im)) (*.f64 re re))
(fma.f64 (sqrt.f64 (*.f64 (sqrt.f64 re) (*.f64 re (*.f64 re re)))) (sqrt.f64 (sqrt.f64 re)) (*.f64 im im))
(neg.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))))) (neg.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1 binary64)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))
(/.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (-.f64 re im))
(/.f64 (exp.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (exp.f64 (log.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (exp.f64 (log.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (exp.f64 (log.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))) (exp.f64 (log.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (exp.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (neg.f64 im)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im))) (-.f64 re im))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) #s(literal 1 binary64))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im (neg.f64 im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (-.f64 re im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1 binary64))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (neg.f64 im))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (-.f64 re im)) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1 binary64))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 im im) (*.f64 im (neg.f64 im))))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 re im)) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (-.f64 re im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 re im) #s(literal 1 binary64))) (*.f64 (-.f64 re im) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (-.f64 re im) (*.f64 (*.f64 im im) (*.f64 im (neg.f64 im))))) (*.f64 (-.f64 re im) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (+.f64 re im)) (-.f64 re im)) (*.f64 (-.f64 re im) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (-.f64 re im) (-.f64 re im)))
(/.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (neg.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (neg.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1 binary64))) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (neg.f64 (-.f64 re im)))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1 binary64))
(*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))
(*.f64 (neg.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal -1 binary64)))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re re (*.f64 im im)))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (/.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))
(*.f64 (pow.f64 (/.f64 (+.f64 re im) (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (exp.f64 (log.f64 (fma.f64 im (*.f64 (*.f64 im im) (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (exp.f64 (neg.f64 (log.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))))
(*.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (neg.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))

simplify638.0ms (11.5%)

Memory
33.1MiB live, 704.1MiB 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
01041080
12961080
29561076
336691008
464251004
08052918
Stop Event
1×iter limit
1×node limit
Counts
132 → 108
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)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
im
im
im
im
im
im
im
im
(* -1 im)
(* -1 im)
(* -1 im)
(* -1 im)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
re
re
re
re
re
re
re
re
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) 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 re re) (/.f64 #s(literal -1/8 binary64) (*.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 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (/.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im #s(literal -1/8 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im #s(literal -1/8 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re)))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)) re)
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1 binary64)) (*.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 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1 binary64))) re (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/8 binary64) (*.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 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal -1/8 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im)) im)
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal -1 binary64)) (*.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 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal -1 binary64))) im (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im)))
(* -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)
(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)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
im
im
im
im
im
im
im
im
(* -1 im)
(neg.f64 im)
(* -1 im)
(neg.f64 im)
(* -1 im)
(neg.f64 im)
(* -1 im)
(neg.f64 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)
(*.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)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
re
re
re
re
re
re
re
re
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) 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 re re) (/.f64 #s(literal -1/8 binary64) (*.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 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (/.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im #s(literal -1/8 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im #s(literal -1/8 binary64))))) (*.f64 (*.f64 re re) (*.f64 re re)))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)) re)
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1 binary64)) (*.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 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1 binary64))) re (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re)))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/8 binary64) (*.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 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal -1/8 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im)) im)
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal -1 binary64)) (*.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 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal -1 binary64))) im (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im)))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))

eval113.0ms (2%)

Memory
-21.9MiB live, 209.3MiB allocated
Compiler

Compiled 19 116 to 1 507 computations (92.1% saved)

prune100.0ms (1.8%)

Memory
17.4MiB live, 212.7MiB allocated
Pruning

4 alts after pruning (2 fresh and 2 done)

PrunedKeptTotal
New8371838
Fresh011
Picked325
Done000
Total8404844
Accuracy
100.0%
Counts
844 → 4
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.9%
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
✓100.0%
(hypot.f64 re im)
✓50.6%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
▶99.5%
im
Compiler

Compiled 27 to 16 computations (40.7% saved)

simplify5.0ms (0.1%)

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

Found 3 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(*.f64 re #s(literal 1/2 binary64))
✓cost-diff0
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
✓cost-diff0
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
Rules
42×lower-*.f32
40×lower-*.f64
16×lower-fma.f32
14×lower-fma.f64
12×*-commutative
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0620
01020
11720
22520
33120
43720
03720
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
im
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
re
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(*.f64 re #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
im
Outputs
im
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
re
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(*.f64 re #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
im

localize26.0ms (0.5%)

Memory
13.5MiB live, 49.1MiB allocated
Localize:

Found 3 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
✓accuracy100.0%
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
✓accuracy100.0%
(*.f64 re #s(literal 1/2 binary64))
Samples
18.0ms256×0valid
Compiler

Compiled 23 to 9 computations (60.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 6.0ms
ival-mult: 3.0ms (46.5% of total)
ival-div: 2.0ms (31% of total)
ival-add: 1.0ms (15.5% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series249.0ms (4.5%)

Memory
-247.2MiB live, 17.4MiB allocated
Counts
3 → 60
Calls
Call 1
Inputs
#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())
#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())
#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())
Outputs
#s(alt im (taylor 0 re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im) (taylor 0 im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt im (taylor -inf im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1))) (taylor -inf im) (#s(alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (patch (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf re) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor 0 im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor inf im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re im)) (taylor -inf im) (#s(alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (patch (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor 0 re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor 0 re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor 0 re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor 0 re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor inf re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor inf re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor inf re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor inf re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor -inf re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor -inf re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor -inf re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 re) (taylor -inf re) (#s(alt (*.f64 re #s(literal 1/2 binary64)) (patch (*.f64 re #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
Calls

15 calls:

TimeVariablePointExpression
241.0ms
im
@-inf
(/ (* re 1/2) im)
1.0ms
re
@inf
(* re 1/2)
1.0ms
re
@inf
(+ (* re (/ (* re 1/2) im)) im)
1.0ms
re
@inf
(/ (* re 1/2) im)
0.0ms
im
@inf
(/ (* re 1/2) im)

rewrite643.0ms (11.6%)

Memory
6.4MiB live, 562.2MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
7 006×lower-fma.f32
7 004×lower-fma.f64
4 222×lower-/.f32
4 220×lower-/.f64
3 812×lower-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0616
01016
13816
225016
3319016
0918416
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
3 → 202
Calls
Call 1
Inputs
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(*.f64 re #s(literal 1/2 binary64))
Outputs
(+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) im)
(+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) 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 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))
(-.f64 (/.f64 (*.f64 im im) (+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im)))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im)))))
(-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))
(-.f64 (/.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im)))) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))) (/.f64 (/.f64 (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im)))) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(-.f64 (/.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (/.f64 (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(-.f64 (/.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))) (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im))))) (/.f64 (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (*.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im))))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)))))) (/.f64 (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)))))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))) (/.f64 (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(-.f64 (/.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) #s(literal 3 binary64)) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))))) (/.f64 (*.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (*.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))) (/.f64 (*.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))))
(fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 re (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re #s(literal 1/2 binary64))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)
(fma.f64 #s(literal 1/2 binary64) (*.f64 re (/.f64 re im)) im)
(fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im)
(fma.f64 im #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) re im)
(fma.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 (/.f64 re im) re)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (exp.f64 (log.f64 re)) im)
(fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (/.f64 (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 (*.f64 re #s(literal -1/2 binary64)) (*.f64 (/.f64 #s(literal -1 binary64) im) re) im)
(fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re (neg.f64 im)) im)
(fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 #s(literal 1 binary64) im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 re (*.f64 re #s(literal 1/2 binary64))) im)
(fma.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 re (/.f64 #s(literal 2 binary64) re)) im)
(fma.f64 (*.f64 re (*.f64 re #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(fma.f64 #s(literal -1 binary64) (neg.f64 im) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) im) im)
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 (*.f64 re re) (/.f64 (/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 (/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (/.f64 (*.f64 re re) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 (/.f64 re im) re)) (/.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)
(fma.f64 (/.f64 re im) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) re)) im)
(fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re #s(literal 1/2 binary64))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (/.f64 (neg.f64 re) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)
(fma.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) (/.f64 re im) im)
(fma.f64 (/.f64 re (neg.f64 im)) (*.f64 re #s(literal -1/2 binary64)) im)
(fma.f64 (/.f64 re #s(literal 1 binary64)) (/.f64 re (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 (/.f64 re (/.f64 im re)) #s(literal 1/2 binary64) im)
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im)))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(fma.f64 (exp.f64 (log.f64 re)) (/.f64 re (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 (exp.f64 (log.f64 (*.f64 re (*.f64 re #s(literal 1/2 binary64))))) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (exp.f64 (log.f64 (*.f64 re #s(literal 1/2 binary64)))) (exp.f64 (log.f64 (/.f64 re im))) im)
(fma.f64 (exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 re))) (exp.f64 (neg.f64 (log.f64 (*.f64 im #s(literal 2 binary64))))) im)
(neg.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))))
(neg.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)))
(/.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 (+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 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 #s(literal -1 binary64) (neg.f64 (/.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) (neg.f64 (/.f64 (+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (neg.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))
(/.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64))) (*.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal -1/8 binary64)))))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im)))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))))))
(/.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))) (+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(/.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64))) #s(literal 1 binary64)) (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal -1/8 binary64))))) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im))) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1 binary64)) (*.f64 (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im im)))) (neg.f64 (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64)))) (neg.f64 (*.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal -1/8 binary64))))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))))) (neg.f64 (*.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))))) (neg.f64 (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))) (neg.f64 (neg.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)))) (neg.f64 (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))
(/.f64 (neg.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (neg.f64 (+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) #s(literal 3 binary64)) (*.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (*.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal -1/8 binary64))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))) (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))
(/.f64 (-.f64 (neg.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 im (neg.f64 im))) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))) (neg.f64 (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64))) #s(literal 1 binary64))) (neg.f64 (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal -1/8 binary64))))) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im))) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(/.f64 (neg.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))) (neg.f64 (neg.f64 (neg.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))) (neg.f64 (neg.f64 (+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) #s(literal 3 binary64)) (*.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (*.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))))) (neg.f64 (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))) (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im))) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))) (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal -1/8 binary64)))))))
(/.f64 (neg.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))) (neg.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im)))))
(/.f64 (neg.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))) (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))))))
(/.f64 (neg.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))) (neg.f64 (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))
(/.f64 (+.f64 (pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (-.f64 (*.f64 (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))) (*.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im (neg.f64 im)) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)) #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 (+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (/.f64 (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))
(*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(*.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (/.f64 #s(literal 1 binary64) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))))
(*.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))) (/.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))))
(*.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im))
(*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))
(*.f64 (neg.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)))))))
(*.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))))) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(*.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im) im)) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)))
(*.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im)))))
(*.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (*.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (*.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)))))) (fma.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (-.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im)))))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im))))) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im))))
(*.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))) (*.f64 (neg.f64 im) (*.f64 im im)))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im))))
(exp.f64 (log.f64 (/.f64 re (*.f64 im #s(literal 2 binary64)))))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(-.f64 (/.f64 #s(literal 0 binary64) im) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(neg.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im)))
(/.f64 re (*.f64 im #s(literal 2 binary64)))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 (*.f64 re #s(literal -1/2 binary64)) (neg.f64 im))
(/.f64 #s(literal 1 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 2 binary64) re))
(/.f64 #s(literal -1 binary64) (/.f64 im (*.f64 re #s(literal -1/2 binary64))))
(/.f64 (/.f64 #s(literal -1 binary64) im) (neg.f64 (/.f64 #s(literal 2 binary64) re)))
(/.f64 (neg.f64 re) (neg.f64 (*.f64 im #s(literal 2 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 re #s(literal -1/2 binary64))) (neg.f64 im))
(/.f64 (*.f64 (*.f64 re #s(literal -1/2 binary64)) #s(literal 1 binary64)) (neg.f64 im))
(/.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) im)
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (*.f64 re #s(literal -1/2 binary64)))) im)
(/.f64 (neg.f64 (*.f64 (*.f64 re #s(literal -1/2 binary64)) #s(literal 1 binary64))) im)
(/.f64 (neg.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))) (neg.f64 im))
(pow.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1 binary64))
(pow.f64 (*.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) (/.f64 im (*.f64 re #s(literal 1/2 binary64)))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(*.f64 #s(literal 1/2 binary64) (*.f64 (neg.f64 re) (/.f64 #s(literal -1 binary64) im)))
(*.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im))
(*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) #s(literal 1 binary64))
(*.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) im))
(*.f64 #s(literal 1 binary64) (/.f64 re (*.f64 im #s(literal 2 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 re #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) re)))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) re)
(*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(*.f64 #s(literal -1/2 binary64) (*.f64 re (/.f64 #s(literal -1 binary64) im)))
(*.f64 #s(literal -1/2 binary64) (/.f64 re (neg.f64 im)))
(*.f64 (/.f64 #s(literal -1 binary64) im) (*.f64 re #s(literal -1/2 binary64)))
(*.f64 (neg.f64 re) (/.f64 #s(literal -1/2 binary64) im))
(*.f64 (neg.f64 re) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal -1 binary64) im)))
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(*.f64 (*.f64 #s(literal 1 binary64) (*.f64 re #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im))
(*.f64 (pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 re #s(literal 1 binary64)) (/.f64 #s(literal 1/2 binary64) im))
(-.f64 #s(literal 0 binary64) (*.f64 re #s(literal -1/2 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64)))) (/.f64 (neg.f64 im) (/.f64 im (*.f64 re #s(literal 1/2 binary64)))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 im (*.f64 re #s(literal -1/2 binary64)))) (/.f64 im (/.f64 im (*.f64 re #s(literal -1/2 binary64)))))
(neg.f64 (*.f64 re #s(literal -1/2 binary64)))
(neg.f64 (*.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im))
(/.f64 im (/.f64 im (*.f64 re #s(literal 1/2 binary64))))
(/.f64 (neg.f64 im) (/.f64 im (*.f64 re #s(literal -1/2 binary64))))
(/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(/.f64 (*.f64 (*.f64 re #s(literal -1/2 binary64)) im) (neg.f64 im))
(/.f64 (neg.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (neg.f64 im))
(/.f64 (neg.f64 (*.f64 (*.f64 re #s(literal -1/2 binary64)) im)) im)
(*.f64 re #s(literal 1/2 binary64))
(*.f64 re (*.f64 (/.f64 #s(literal 1/2 binary64) im) im))
(*.f64 #s(literal 1/2 binary64) re)
(*.f64 #s(literal 1/2 binary64) (neg.f64 (neg.f64 re)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) im))
(*.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
(*.f64 im (/.f64 re (*.f64 im #s(literal 2 binary64))))
(*.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) im)
(*.f64 (*.f64 re #s(literal -1/2 binary64)) (*.f64 (/.f64 #s(literal -1 binary64) im) im))
(*.f64 #s(literal 1 binary64) (*.f64 re #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 (*.f64 re #s(literal 1/2 binary64)) im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re im))
(*.f64 #s(literal -1 binary64) (*.f64 re #s(literal -1/2 binary64)))
(*.f64 #s(literal -1/2 binary64) (neg.f64 re))
(*.f64 (neg.f64 re) #s(literal -1/2 binary64))
(*.f64 (neg.f64 (neg.f64 re)) #s(literal 1/2 binary64))

simplify196.0ms (3.5%)

Memory
-3.6MiB live, 317.4MiB allocated
Algorithm
1×egg-herbie
Rules
5 470×lower-fma.f64
5 470×lower-fma.f32
3 074×lower-*.f64
3 074×lower-*.f32
1 306×lower--.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
031348
174348
2165348
3561348
42423348
55250348
67707348
08395330
Stop Event
1×iter limit
1×node limit
Counts
60 → 57
Calls
Call 1
Inputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) (*.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) (*.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) (*.f64 im im)) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)

eval31.0ms (0.6%)

Memory
1.8MiB live, 78.8MiB allocated
Compiler

Compiled 8 333 to 590 computations (92.9% saved)

prune35.0ms (0.6%)

Memory
22.0MiB live, 103.4MiB allocated
Pruning

4 alts after pruning (0 fresh and 4 done)

PrunedKeptTotal
New2590259
Fresh000
Picked022
Done022
Total2594263
Accuracy
100.0%
Counts
263 → 4
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓99.9%
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
✓100.0%
(hypot.f64 re im)
✓50.6%
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
✓99.5%
im
Compiler

Compiled 66 to 32 computations (51.5% saved)

regimes19.0ms (0.3%)

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

6 calls:

4.0ms
(*.f64 re re)
3.0ms
im
3.0ms
(+.f64 (*.f64 re re) (*.f64 im im))
3.0ms
re
3.0ms
(*.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)

regimes18.0ms (0.3%)

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

6 calls:

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

Compiled 35 to 21 computations (40% saved)

regimes16.0ms (0.3%)

Memory
-13.5MiB live, 26.5MiB allocated
Accuracy

Total -62.5b remaining (-18248.1%)

Threshold costs -62.5b (-18248.1%)

Counts
5 → 1
Calls
Call 1
Inputs
im
(neg.f64 re)
(sqrt.f64 (*.f64 im im))
(sqrt.f64 (*.f64 re re))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
Outputs
im
Calls

6 calls:

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

Compiled 35 to 21 computations (40% saved)

simplify5.0ms (0.1%)

Memory
9.9MiB live, 9.9MiB allocated
Algorithm
1×egg-herbie
Rules
2×*-commutative_binary64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0712
1812
Stop Event
1×saturated
Calls
Call 1
Inputs
(hypot.f64 re im)
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
im
Outputs
(hypot.f64 re im)
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
im

soundness480.0ms (8.7%)

Memory
-14.9MiB live, 304.0MiB allocated
Rules
18 004×lower-fma.f64
18 004×lower-fma.f32
5 720×lower-fma.f64
5 720×lower-fma.f32
5 072×lower-*.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01028
01724
14822
224222
3218022
0857022
0621
01021
12921
219621
3178821
0862415
0104620
1296620
2956618
33681584
46441582
08069530
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 38 to 22 computations (42.1% saved)

preprocess29.0ms (0.5%)

Memory
22.7MiB live, 60.5MiB allocated
Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 78 to 44 computations (43.6% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...