math.abs on complex

Time bar (total: 4.1s)

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)

sample836.0ms (20.6%)

Memory
14.7MiB live, 722.1MiB allocated
Samples
676.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 405.0ms
ival-hypot: 397.0ms (98% of total)
ival-true: 5.0ms (1.2% of total)
ival-assert: 3.0ms (0.7% of total)
Bogosity

preprocess35.0ms (0.9%)

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

Useful iterations: 0 (0.0ms)

IterNodesCost
01850
13650
27850
314650
420550
522050
622250
068
178
073
Stop Event
1×iter limit
1×saturated
1×saturated
Calls
Call 1
Inputs
(sqrt (+ (* re re) (* im im)))
Outputs
(sqrt (+ (* re re) (* im im)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
Call 2
Inputs
(sqrt (+ (* re re) (* im im)))
(sqrt (+ (* (neg re) (neg re)) (* im im)))
(sqrt (+ (* re re) (* (neg im) (neg im))))
(neg (sqrt (+ (* (neg re) (neg re)) (* im im))))
(neg (sqrt (+ (* re re) (* (neg im) (neg im)))))
(sqrt (+ (* im im) (* re re)))
Outputs
(sqrt (+ (* re re) (* im im)))
(sqrt (+ (* (neg re) (neg re)) (* im im)))
(sqrt (+ (* re re) (* im im)))
(sqrt (+ (* re re) (* (neg im) (neg im))))
(sqrt (+ (* re re) (* im im)))
(neg (sqrt (+ (* (neg re) (neg re)) (* im im))))
(neg (sqrt (+ (* re re) (* im im))))
(neg (sqrt (+ (* re re) (* (neg im) (neg im)))))
(neg (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* im im) (* re re)))
(sqrt (+ (* re re) (* im im)))
Symmetry

(abs re)

(abs im)

(sort re im)

explain94.0ms (2.3%)

Memory
2.1MiB live, 160.9MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1300-3(5.195862151411497e-270 5.364293299639545e-161)(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-rescue1070
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow107
↳(*.f64 re re)overflow12
↳(*.f64 im im)overflow107
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue200
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow20
↳(*.f64 re re)underflow103
↳(*.f64 im im)underflow20
Confusion
Predicted +Predicted -
+1273
-0126
Precision
1.0
Recall
0.9769230769230769
Confusion?
Predicted +Predicted MaybePredicted -
+12703
-00126
Precision?
1.0
Recall?
0.9769230769230769
Freqs
test
numberfreq
0129
1127
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
35.0ms512×0valid
Compiler

Compiled 70 to 28 computations (60% saved)

Precisions
Click to see histograms. Total time spent on operations: 22.0ms
ival-mult: 12.0ms (53.9% of total)
ival-hypot: 8.0ms (36% of total)
ival-add: 2.0ms (9% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.5MiB live, 0.5MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

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

Compiled 10 to 6 computations (40% saved)

simplify3.0ms (0.1%)

Memory
10.2MiB live, 10.2MiB 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×+-lowering-+.f64
4×*-lowering-*.f32
4×accelerator-lowering-hypot.f32
4×*-lowering-*.f64
4×+-lowering-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0623
1723
0717
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(sqrt (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(* re re)
re
(* im im)
im
Outputs
(sqrt (+ (* re re) (* im im)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(+ (* re re) (* im im))
(fma.f64 re re (*.f64 im im))
(* re re)
(*.f64 re re)
re
(* im im)
(*.f64 im im)
im

localize37.0ms (0.9%)

Memory
5.9MiB live, 45.3MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(*.f64 re re)
✓accuracy100.0%
(*.f64 im im)
✓accuracy100.0%
(+.f64 (*.f64 re re) (*.f64 im im))
✓accuracy53.3%
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Samples
30.0ms256×0valid
Compiler

Compiled 25 to 8 computations (68% saved)

Precisions
Click to see histograms. Total time spent on operations: 24.0ms
ival-hypot: 20.0ms (84% of total)
ival-mult: 3.0ms (12.6% of total)
ival-add: 1.0ms (4.2% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series4.0ms (0.1%)

Memory
7.4MiB live, 7.4MiB allocated
Counts
4 → 72
Calls
Call 1
Inputs
#<alt (+ (* re re) (* im im))>
#<alt (sqrt (+ (* re re) (* im im)))>
#<alt (* re re)>
#<alt (* im im)>
Outputs
#<alt (pow im 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<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)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<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)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<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))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<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)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<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)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<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))))))))>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
Calls

18 calls:

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

rewrite654.0ms (16.1%)

Memory
-2.4MiB live, 554.8MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 720×accelerator-lowering-fma.f32
5 720×accelerator-lowering-fma.f64
4 038×/-lowering-/.f32
4 038×/-lowering-/.f64
3 184×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0621
12521
219221
3178621
0861415
Stop Event
1×iter limit
1×node limit
Counts
4 → 245
Calls
Call 1
Inputs
(+ (* re re) (* im im))
(sqrt (+ (* re re) (* im im)))
(* re re)
(* 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 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))))
(-.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 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 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 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im 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)))))) (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 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 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 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.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 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.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 #s(literal 0 binary64) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 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 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 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 (*.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 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 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 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))))
(-.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 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (/.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (/.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 re (+.f64 re im)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 re im)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 re im)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 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 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im 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)))))
(neg.f64 (/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(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 (/.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 re re (*.f64 im im))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 re re (*.f64 im im))))
(/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))
(/.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 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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 #s(literal 1 binary64) (/.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 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 (*.f64 im im) (*.f64 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 (*.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 (fma.f64 (*.f64 im im) (*.f64 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 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im 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))))))
(/.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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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)))))))) #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 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 (*.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 (fma.f64 (*.f64 im im) (*.f64 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 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re 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)))) #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 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.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 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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))))))
(/.f64 #s(literal 1 binary64) (/.f64 (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 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 re im) (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 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 (fma.f64 (*.f64 im im) (*.f64 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 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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)))))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (*.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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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))))))))) (neg.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 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 (neg.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 (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 (-.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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1 binary64)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 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 (fma.f64 (*.f64 im im) (*.f64 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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (exp.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.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 (*.f64 im im)) (neg.f64 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)) (*.f64 (*.f64 im (*.f64 im 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 (*.f64 im 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 (*.f64 im 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 (*.f64 im 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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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)))))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.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 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))) (neg.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))) (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 (*.f64 im im) (*.f64 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)))
(/.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 re re (*.f64 im im))) #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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (neg.f64 (*.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 re re (*.f64 im im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.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 (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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 im (*.f64 im (*.f64 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 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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (neg.f64 (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (neg.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 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)))))
(*.f64 (pow.f64 (/.f64 (+.f64 re im) (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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))))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 (*.f64 im im) (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(*.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))))))
(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 im re)
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.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 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (sqrt.f64 (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re)))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 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 (sqrt.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 (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 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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)))))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.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 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.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 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))) (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 (*.f64 im im) (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.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 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (sqrt.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.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 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 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 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(*.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 (*.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 re re (*.f64 im im)) (+.f64 re im)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 re im)))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 im (*.f64 im (*.f64 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 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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (neg.f64 (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (neg.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 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 (pow.f64 (fma.f64 (*.f64 im im) (*.f64 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 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) #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 (fma.f64 re re (*.f64 im im)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(*.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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 im (*.f64 im (*.f64 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 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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (neg.f64 (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (neg.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 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im))))))
(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)

simplify976.0ms (24.1%)

Memory
-33.6MiB live, 736.1MiB allocated
Algorithm
1×egg-herbie
Rules
18 004×accelerator-lowering-fma.f32
18 004×accelerator-lowering-fma.f64
5 072×*-lowering-*.f32
5 072×*-lowering-*.f64
2 260×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0104620
1296620
2956618
33681584
46441582
08069530
Stop Event
1×iter limit
1×node limit
Counts
72 → 72
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)

eval41.0ms (1%)

Memory
14.4MiB live, 98.7MiB allocated
Compiler

Compiled 14 153 to 961 computations (93.2% saved)

prune48.0ms (1.2%)

Memory
9.7MiB live, 126.5MiB allocated
Pruning

4 alts after pruning (4 fresh and 0 done)

PrunedKeptTotal
New3134317
Fresh000
Picked101
Done000
Total3144318
Accuracy
100.0%
Counts
318 → 4
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.4%
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
▶100.0%
(hypot.f64 re im)
▶53.3%
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
▶98.3%
im
Compiler

Compiled 27 to 16 computations (40.7% saved)

simplify7.0ms (0.2%)

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

Found 7 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)
✓cost-diff5120
(hypot.f64 re im)
✓cost-diff0
(*.f64 re re)
✓cost-diff0
(fma.f64 im im (*.f64 re re))
✓cost-diff0
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
Rules
44×*-lowering-*.f32
44×*-lowering-*.f64
20×accelerator-lowering-fma.f32
20×accelerator-lowering-fma.f64
12×associate-*l*
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01351
12051
22751
33351
43851
03839
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
im
(sqrt (+ (* im im) (* re re)))
(+ (* im im) (* re re))
im
(* re re)
re
(sqrt (+ (* re re) (* im im)))
re
im
(+ (* re (/ (* re 1/2) im)) im)
re
(/ (* re 1/2) im)
(* re 1/2)
1/2
im
Outputs
im
(sqrt (+ (* im im) (* re re)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(+ (* im im) (* re re))
(fma.f64 im im (*.f64 re re))
im
(* re re)
(*.f64 re re)
re
(sqrt (+ (* re re) (* im im)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
re
im
(+ (* re (/ (* re 1/2) im)) im)
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
re
(/ (* re 1/2) im)
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* re 1/2)
(*.f64 re #s(literal 1/2 binary64))
1/2
#s(literal 1/2 binary64)
im

localize40.0ms (1%)

Memory
11.4MiB live, 128.3MiB allocated
Localize:

Found 7 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))
✓accuracy100.0%
(hypot.f64 re im)
✓accuracy100.0%
(fma.f64 im im (*.f64 re re))
✓accuracy100.0%
(*.f64 re re)
✓accuracy53.3%
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
Samples
27.0ms256×0valid
Compiler

Compiled 45 to 14 computations (68.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 16.0ms
ival-mult: 6.0ms (37.9% of total)
ival-hypot: 4.0ms (25.3% of total)
ival-div: 2.0ms (12.6% of total)
ival-add: 2.0ms (12.6% of total)
ival-sqrt: 2.0ms (12.6% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series12.0ms (0.3%)

Memory
-11.8MiB live, 28.9MiB allocated
Counts
7 → 144
Calls
Call 1
Inputs
#<alt (sqrt (+ (* im im) (* re re)))>
#<alt (+ (* im im) (* re re))>
#<alt (* re re)>
#<alt (sqrt (+ (* re re) (* im im)))>
#<alt (+ (* re (/ (* re 1/2) im)) im)>
#<alt (/ (* re 1/2) im)>
#<alt (* re 1/2)>
Outputs
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<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)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<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)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<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))))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<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)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<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)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<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))))))))>
#<alt (pow re 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<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)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<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)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<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))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<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)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<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)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<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))))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt im>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
Calls

36 calls:

TimeVariablePointExpression
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
@0
(/ (* re 1/2) im)
0.0ms
im
@inf
(/ (* re 1/2) im)

rewrite319.0ms (7.9%)

Memory
10.1MiB live, 519.1MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 968×accelerator-lowering-fma.f32
5 968×accelerator-lowering-fma.f64
4 334×*-lowering-*.f32
4 334×*-lowering-*.f64
2 576×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01343
16543
251743
3622943
0834331
Stop Event
1×iter limit
1×node limit
Counts
7 → 348
Calls
Call 1
Inputs
(sqrt (+ (* im im) (* re re)))
(+ (* im im) (* re re))
(* re re)
(sqrt (+ (* re re) (* im im)))
(+ (* re (/ (* re 1/2) im)) im)
(/ (* re 1/2) im)
(* re 1/2)
Outputs
(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 (log.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/2 binary64)))
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 re im)
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (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 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (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 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (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)))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) #s(literal -1 binary64))
(pow.f64 (/.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))))) #s(literal -1 binary64))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.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 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(exp.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re))))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re))))
(fma.f64 im im (*.f64 re re))
(fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 (*.f64 im im) (/.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (*.f64 im (*.f64 im im)) (/.f64 im (*.f64 (+.f64 im re) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (*.f64 (-.f64 re im) (+.f64 im re))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)) (*.f64 re re))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(fma.f64 (/.f64 re (+.f64 im re)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 im re)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 im re)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(fma.f64 (/.f64 im (+.f64 im re)) (/.f64 (*.f64 im (*.f64 im im)) (-.f64 im re)) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im im) (+.f64 im re)) (/.f64 (*.f64 im im) (-.f64 im re)) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (+.f64 im re)) (/.f64 im (-.f64 im re)) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (fma.f64 im im (*.f64 re re)) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 im im (*.f64 re re)) (neg.f64 (/.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 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(neg.f64 (/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(neg.f64 (/.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)))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(neg.f64 (/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (*.f64 (+.f64 im re) (-.f64 im re))))
(neg.f64 (/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im 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) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (-.f64 re im) (+.f64 im re)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im 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 im re)))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (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 im re) (-.f64 im re)))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (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 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #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 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 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 im re))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 im re) (-.f64 im 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 im re) (-.f64 im re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (+.f64 im re) (-.f64 im 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 im re)))) #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 im re))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (neg.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (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 (-.f64 (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal 3 binary64))) (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))) (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))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re)))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re))))) (fma.f64 (*.f64 im im) (/.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (-.f64 (*.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 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re))))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))
(/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1 binary64)) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal 1 binary64)) (*.f64 (-.f64 re im) (+.f64 im re)))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re)))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))) (fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im 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 im re) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 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 im re)))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))) (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 im re) (-.f64 im re))) (+.f64 im re)) (-.f64 im re))
(/.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re))) (+.f64 im re)) (-.f64 re im))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (+.f64 im re) (-.f64 im re))))
(*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))))
(*.f64 (*.f64 (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 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re))))
(*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (+.f64 im re))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (fma.f64 im im (*.f64 re re)))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (fma.f64 im im (*.f64 re re)))
(*.f64 (/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 re (*.f64 re (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))))) (fma.f64 (*.f64 re (*.f64 re (*.f64 (-.f64 re im) (+.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 (-.f64 re im) (+.f64 im re)))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 (-.f64 re im) (+.f64 im re))))))) (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 (-.f64 re im) (+.f64 im re))))))
(*.f64 (/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.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))))) (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.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)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 re))) #s(literal 2 binary64)))
(pow.f64 re #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 2 binary64))
(*.f64 re re)
(*.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)))
(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 (log.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/2 binary64)))
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 re im)
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (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 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (neg.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (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 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (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)))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) #s(literal -1 binary64))
(pow.f64 (/.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))))) #s(literal -1 binary64))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.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 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(+.f64 im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(+.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) im)
(+.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #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 im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 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 im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(-.f64 (/.f64 (*.f64 im im) (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))) (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))))
(fma.f64 im #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 re (/.f64 (/.f64 (*.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 im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 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 im) (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)
(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 (/.f64 re (*.f64 im #s(literal 2 binary64))) re im)
(fma.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (/.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re #s(literal 1/2 binary64)))) im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (/.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (*.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 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 #s(literal 1 binary64) im (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 (/.f64 #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 (*.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 im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re #s(literal 1/2 binary64)))) im) (/.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (/.f64 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 re (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (*.f64 (*.f64 re (*.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) 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 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))))
(fma.f64 (/.f64 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 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (fma.f64 im (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(neg.f64 (/.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(neg.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(neg.f64 (/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 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 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 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 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))))
(/.f64 (neg.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 (*.f64 im im) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 re (*.f64 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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 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 (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im im) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 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 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (neg.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)))) (neg.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)))
(/.f64 (neg.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)))) (neg.f64 (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 re (*.f64 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 (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #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 re (*.f64 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 im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (*.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #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 im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 re (*.f64 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 re (*.f64 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 im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))) (/.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im))))) (+.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #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 im) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) #s(literal 1 binary64)) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)) (pow.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im))) (fma.f64 (*.f64 im im) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im))) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (*.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im))))
(*.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) 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 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (*.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (/.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))))
(*.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)))
(*.f64 (neg.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)))))
(*.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im))) (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))
(*.f64 (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)))
(*.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))))
(*.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))) (*.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))) (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (fma.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))) (-.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) (neg.f64 im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)))))) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)))))
(*.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (fma.f64 im (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))))
(exp.f64 (*.f64 (log.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 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)))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64)))))
(/.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) (*.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)
(pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(*.f64 #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 (neg.f64 re) 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) (/.f64 #s(literal -1 binary64) im)))
(*.f64 (neg.f64 re) (/.f64 #s(literal 1/2 binary64) (neg.f64 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 (/.f64 (neg.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 #s(literal 0 binary64) (*.f64 re #s(literal -1/2 binary64)))
(neg.f64 (*.f64 re #s(literal -1/2 binary64)))
(*.f64 re #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) re)
(*.f64 #s(literal 1/2 binary64) (neg.f64 (neg.f64 re)))
(*.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 re #s(literal 1/2 binary64)))
(*.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))

simplify394.0ms (9.7%)

Memory
18.6MiB live, 733.6MiB allocated
Algorithm
1×egg-herbie
Rules
16 212×accelerator-lowering-fma.f32
16 212×accelerator-lowering-fma.f64
4 244×*-lowering-*.f32
4 244×*-lowering-*.f64
2 514×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01181396
13291396
210251392
339551264
475251264
082671164
Stop Event
1×iter limit
1×node limit
Counts
144 → 144
Calls
Call 1
Inputs
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))))))))
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))))))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(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))))))))
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
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 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 im (*.f64 im (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re))) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal -1/8 binary64) (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (/.f64 #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 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal -1/8 binary64) (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 #s(literal 1/8 binary64) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) im) (neg.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) 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))))))))
(-.f64 (*.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 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64)))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.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 re (*.f64 re (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1 binary64)) (*.f64 im (/.f64 (*.f64 #s(literal 1/2 binary64) im) re)))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) #s(literal 1 binary64))) (*.f64 im (/.f64 (*.f64 #s(literal 1/2 binary64) im) re)))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.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 re (*.f64 re (*.f64 re re)))) #s(literal -1 binary64)) (neg.f64 (*.f64 im (/.f64 (*.f64 #s(literal 1/2 binary64) im) re))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(neg.f64 (fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) #s(literal 1 binary64))) (*.f64 im (/.f64 (*.f64 #s(literal 1/2 binary64) im) re))))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(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 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.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 re (*.f64 re (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1 binary64)) (*.f64 im (/.f64 (*.f64 #s(literal 1/2 binary64) im) re)))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) #s(literal 1 binary64))) (*.f64 im (/.f64 (*.f64 #s(literal 1/2 binary64) im) re)))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.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 re (*.f64 re (*.f64 re re)))) #s(literal -1 binary64)) (neg.f64 (*.f64 im (/.f64 (*.f64 #s(literal 1/2 binary64) im) re))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(neg.f64 (fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) #s(literal 1 binary64))) (*.f64 im (/.f64 (*.f64 #s(literal 1/2 binary64) im) re))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 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 im (*.f64 im (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re))) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal -1/8 binary64) (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (/.f64 #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 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 (*.f64 re re) (*.f64 #s(literal -1/8 binary64) (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 #s(literal 1/8 binary64) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) im) (neg.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) 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))))))))
(-.f64 (*.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 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64)))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) 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 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) 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 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) 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 re (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im)) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))

eval55.0ms (1.3%)

Memory
4.6MiB live, 118.4MiB allocated
Compiler

Compiled 13 245 to 967 computations (92.7% saved)

prune43.0ms (1.1%)

Memory
17.4MiB live, 100.2MiB allocated
Pruning

4 alts after pruning (0 fresh and 4 done)

PrunedKeptTotal
New4920492
Fresh000
Picked044
Done000
Total4924496
Accuracy
100.0%
Counts
496 → 4
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓99.4%
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
✓100.0%
(hypot.f64 re im)
✓53.3%
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓98.3%
im
Compiler

Compiled 56 to 29 computations (48.2% saved)

regimes14.0ms (0.4%)

Memory
-11.6MiB live, 27.6MiB allocated
Counts
5 → 1
Calls
Call 1
Inputs
im
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(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:

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

Compiled 35 to 21 computations (40% saved)

regimes13.0ms (0.3%)

Memory
-8.6MiB live, 30.5MiB allocated
Counts
4 → 1
Calls
Call 1
Inputs
im
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(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:

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

Compiled 35 to 21 computations (40% saved)

regimes9.0ms (0.2%)

Memory
25.1MiB live, 25.1MiB allocated
Accuracy

Total -29.4b remaining (-2727.9%)

Threshold costs -29.4b (-2727.9%)

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

6 calls:

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

Compiled 35 to 21 computations (40% saved)

simplify7.0ms (0.2%)

Memory
-23.9MiB live, 15.4MiB 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

soundness353.0ms (8.7%)

Memory
16.2MiB live, 298.8MiB allocated
Rules
18 004×accelerator-lowering-fma.f32
18 004×accelerator-lowering-fma.f64
5 720×accelerator-lowering-fma.f32
5 720×accelerator-lowering-fma.f64
5 072×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0621
12521
219221
3178621
0861415
0104620
1296620
2956618
33681584
46441582
08069530
Stop Event
1×done
1×iter limit
1×node limit
1×iter limit
1×node limit
Compiler

Compiled 32 to 18 computations (43.8% saved)

preprocess57.0ms (1.4%)

Memory
-23.6MiB live, 98.1MiB allocated
Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 78 to 44 computations (43.6% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...