math.sqrt on complex, real part

Time bar (total: 9.7s)

analyze87.0ms (0.9%)

Memory
-0.3MiB live, 194.1MiB allocated
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.9%0.1%0%0%0%0
0%0%99.9%0.1%0%0%0%1
50%50%50%0.1%0%0%0%2
50%50%50%0.1%0%0%0%3
50%50%50%0.1%0%0%0%4
62.5%62.4%37.5%0.1%0%0%0%5
62.5%62.4%37.5%0.1%0%0%0%6
68.8%68.7%31.2%0.1%0%0%0%7
68.8%68.7%31.2%0.1%0%0%0%8
71.9%71.8%28.1%0.1%0%0%0%9
71.9%71.8%28.1%0.1%0%0%0%10
73.4%73.4%26.5%0.1%0%0%0%11
73.4%73.4%26.5%0.1%0%0%0%12
Compiler

Compiled 17 to 11 computations (35.3% saved)

sample1.6s (16.7%)

Memory
-13.0MiB live, 2 217.3MiB allocated
Samples
510.0ms6 183×0valid
181.0ms816×2valid
172.0ms806×1valid
142.0ms451×3valid
Precisions
Click to see histograms. Total time spent on operations: 743.0ms
ival-hypot: 338.0ms (45.5% of total)
ival-mult: 165.0ms (22.2% of total)
ival-sqrt: 103.0ms (13.9% of total)
ival-add: 90.0ms (12.1% of total)
adjust: 30.0ms (4% of total)
exact: 7.0ms (0.9% of total)
ival-true: 6.0ms (0.8% of total)
ival-assert: 3.0ms (0.4% of total)
Bogosity

preprocess28.0ms (0.3%)

Memory
2.9MiB live, 41.9MiB allocated
Algorithm
2×egg-herbie
Rules
122×distribute-rgt-in
108×sub-neg
86×distribute-lft-in
82×unsub-neg
78×distribute-lft-neg-in
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03690
110690
218190
327190
440890
553290
665590
775590
878390
01215
12215
22415
02410
Stop Event
1×iter limit
1×saturated
1×saturated
Calls
Call 1
Inputs
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))
Outputs
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
Call 2
Inputs
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* (neg re) (neg re)) (* im im))) (neg re)))))
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* (neg im) (neg im)))) re))))
(neg (* 1/2 (sqrt (* 2 (+ (sqrt (+ (* (neg re) (neg re)) (* im im))) (neg re))))))
(neg (* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* (neg im) (neg im)))) re)))))
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) im))))
Outputs
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))
(* 1/2 (sqrt (* 2 (+ re (sqrt (+ (* re re) (* im im)))))))
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* (neg re) (neg re)) (* im im))) (neg re)))))
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* (neg im) (neg im)))) re))))
(* 1/2 (sqrt (* 2 (+ re (sqrt (+ (* re re) (* im im)))))))
(neg (* 1/2 (sqrt (* 2 (+ (sqrt (+ (* (neg re) (neg re)) (* im im))) (neg re))))))
(* (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))) -1/2)
(neg (* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* (neg im) (neg im)))) re)))))
(* (sqrt (* 2 (+ re (sqrt (+ (* re re) (* im im)))))) -1/2)
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) im))))
(* 1/2 (sqrt (* 2 (+ im (sqrt (+ (* re re) (* im im)))))))
Symmetry

(abs im)

explain170.0ms (1.8%)

Memory
-5.6MiB live, 468.2MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1320-0-(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
340-0-(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
150-0-(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
00-0-(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
00-0-(*.f64 re re)
00-0-im
00-0-(+.f64 (*.f64 re re) (*.f64 im im))
00-0-#s(literal 2 binary64)
00-0-(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
00-0-re
00-0-#s(literal 1/2 binary64)
00-0-(*.f64 im im)
Explanations
Click to see full explanations table
OperatorSubexpressionExplanationCount
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))oflow-rescue1190
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow119
↳(*.f64 re re)overflow82
↳(*.f64 im im)overflow66
+.f64(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)cancellation340
sqrt.f64(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))uflow-rescue140
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow13
↳(*.f64 im im)underflow52
↳(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))underflow6
↳(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))underflow20
↳(*.f64 re re)underflow59
↳(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)underflow20
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue130
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow13
↳(*.f64 re re)underflow59
↳(*.f64 im im)underflow52
sqrt.f64(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))oflow-rescue10
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow119
↳(*.f64 re re)overflow82
↳(*.f64 im im)overflow66
↳(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))overflow1
Confusion
Predicted +Predicted -
+1570
-099
Precision
1.0
Recall
1.0
Confusion?
Predicted +Predicted MaybePredicted -
+15700
-0099
Precision?
1.0
Recall?
1.0
Freqs
test
numberfreq
099
1133
224
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
40.0ms404×0valid
14.0ms62×1valid
7.0ms18×3valid
7.0ms28×2valid
Compiler

Compiled 188 to 52 computations (72.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 44.0ms
ival-mult: 16.0ms (36.5% of total)
ival-hypot: 14.0ms (31.9% of total)
ival-add: 6.0ms (13.7% of total)
ival-sqrt: 5.0ms (11.4% of total)
adjust: 2.0ms (4.6% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.6MiB live, 0.6MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

Memory
2.2MiB live, 2.2MiB allocated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶41.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
Compiler

Compiled 17 to 12 computations (29.4% saved)

simplify4.0ms (0%)

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

Found 4 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
✓cost-diff0
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
✓cost-diff128
(+.f64 (*.f64 re re) (*.f64 im im))
Rules
20×*-lowering-*.f32
20×*-lowering-*.f64
12×+-lowering-+.f64
12×+-lowering-+.f32
12×accelerator-lowering-fma.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01275
12275
22475
02449
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))
1/2
(sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re)))
(* 2 (+ (sqrt (+ (* re re) (* im im))) re))
2
(+ (sqrt (+ (* re re) (* im im))) re)
(sqrt (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(* re re)
re
(* im im)
im
Outputs
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
1/2
#s(literal 1/2 binary64)
(sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re)))
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(* 2 (+ (sqrt (+ (* re re) (* im im))) re))
(*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
2
#s(literal 2 binary64)
(+ (sqrt (+ (* re re) (* im im))) re)
(+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(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

localize86.0ms (0.9%)

Memory
8.4MiB live, 92.1MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(+.f64 (*.f64 re re) (*.f64 im im))
✓accuracy94.5%
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
✓accuracy87.4%
(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
✓accuracy52.3%
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Samples
59.0ms202×0valid
5.0ms31×1valid
3.0ms14×2valid
3.0ms9×3valid
Compiler

Compiled 77 to 14 computations (81.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 50.0ms
ival-mult: 37.0ms (74.1% of total)
ival-hypot: 6.0ms (12% of total)
ival-add: 3.0ms (6% of total)
ival-sqrt: 2.0ms (4% of total)
adjust: 1.0ms (2% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

series21.0ms (0.2%)

Memory
6.0MiB live, 42.8MiB allocated
Counts
6 → 144
Calls
Call 1
Inputs
#<alt (+ (* re re) (* im im))>
#<alt (* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))>
#<alt (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re)))>
#<alt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))>
#<alt (sqrt (+ (* re re) (* im im)))>
#<alt (+ (sqrt (+ (* re re) (* im im))) re)>
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 (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))))>
#<alt (* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))>
#<alt (* re (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))>
#<alt (* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))>
#<alt (* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/64 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))))>
#<alt (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))>
#<alt (+ (* 1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))>
#<alt (+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))>
#<alt (+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/1024 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))>
#<alt (* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))>
#<alt (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))))>
#<alt (+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* -1/4 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/8 (sqrt (/ 1 (pow re 3)))))))>
#<alt (+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/4 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/4 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))>
#<alt (* -1/2 (* (sqrt im) (* (sqrt -1) (sqrt 2))))>
#<alt (* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))>
#<alt (* -1 (* im (+ (* -1 (/ (+ (* 1/16 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (+ (* 1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))>
#<alt (+ (* re (+ (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (* (sqrt im) (sqrt 2)))>
#<alt (+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))) (* (sqrt im) (sqrt 2)))>
#<alt (* (sqrt re) (pow (sqrt 2) 2))>
#<alt (* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))>
#<alt (* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))>
#<alt (* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/32 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))>
#<alt (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))>
#<alt (+ (* 1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))>
#<alt (+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))>
#<alt (+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/512 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))>
#<alt (* (sqrt re) (pow (sqrt 2) 2))>
#<alt (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* (sqrt re) (pow (sqrt 2) 2)))>
#<alt (+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/4 (sqrt (/ 1 (pow re 3)))))))>
#<alt (+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/2 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))>
#<alt (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* -1 (* (sqrt im) (* (sqrt -1) (sqrt 2))))>
#<alt (* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))>
#<alt (* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* -1 (* im (+ (* -1 (/ (+ (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/4 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* 2 im)>
#<alt (+ (* 2 im) (* 2 re))>
#<alt (+ (* 2 im) (* re (+ 2 (/ re im))))>
#<alt (+ (* 2 im) (* re (+ 2 (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))))))>
#<alt (* 4 re)>
#<alt (* re (+ 4 (/ (pow im 2) (pow re 2))))>
#<alt (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/8 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re))>
#<alt (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re))>
#<alt (* -1 (/ (+ (* -1 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2)))) re))>
#<alt (* 4 re)>
#<alt (+ (* 4 re) (/ (pow im 2) re))>
#<alt (+ (* 4 re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re))))>
#<alt (+ (* 4 re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re))))>
#<alt (* 2 im)>
#<alt (* im (+ 2 (* 2 (/ re im))))>
#<alt (* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 2 (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2))))))>
#<alt (* -2 im)>
#<alt (* -1 (* im (+ 2 (* -2 (/ re im)))))>
#<alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (pow re 2) im)) (* 2 re)) im)))))>
#<alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im)) (* 2 re)) im)))))>
#<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 re)>
#<alt (+ im (* re (+ 1 (* 1/2 (/ re im)))))>
#<alt (+ im (* re (+ 1 (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))>
#<alt (* 2 re)>
#<alt (* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 2 (+ (* -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/2 (/ (pow im 2) re))>
#<alt (* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re))>
#<alt (* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re))>
#<alt (* -1 (/ (+ (* -1/2 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2))))) re))>
#<alt (* 2 re)>
#<alt (+ (* 1/2 (/ (pow im 2) re)) (* 2 re))>
#<alt (+ (* 2 re) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ (* 2 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 (/ re im)))>
#<alt (* im (+ 1 (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im)))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* -1 (/ re im)))))>
#<alt (* -1 (* im (+ 1 (* -1 (/ (+ re (* -1/2 (/ (pow re 2) im))) im)))))>
#<alt (* -1 (* im (+ 1 (* -1 (/ (+ re (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im))) im)))))>
Calls

36 calls:

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

rewrite980.0ms (10.1%)

Memory
-47.2MiB live, 628.8MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 816×accelerator-lowering-fma.f32
5 816×accelerator-lowering-fma.f64
3 750×*-lowering-*.f32
3 750×*-lowering-*.f64
2 178×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01265
15365
239065
3421565
0833438
Stop Event
1×iter limit
1×node limit
Counts
6 → 285
Calls
Call 1
Inputs
(+ (* re re) (* im im))
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re))))
(sqrt (* 2 (+ (sqrt (+ (* re re) (* im im))) re)))
(* 2 (+ (sqrt (+ (* re re) (* im im))) re))
(sqrt (+ (* re re) (* im im)))
(+ (sqrt (+ (* re re) (* im im))) re)
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 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(fabs.f64 (fma.f64 re re (*.f64 im 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 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))))
(sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im 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 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)) (*.f64 re re))
(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 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (*.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 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.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))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.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))))) (*.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 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.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))))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (-.f64 #s(literal 0 binary64) (*.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 (-.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 re (*.f64 re (*.f64 re re))) (*.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)))) (/.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 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (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 (*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.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))))) (/.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))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (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 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 4 binary64))
(pow.f64 (*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1 binary64))
(*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.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 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(*.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 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 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 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))) (sqrt.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/4 binary64))) (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (fma.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64) (*.f64 (log.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))))
(exp.f64 (fma.f64 (log.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(exp.f64 (fma.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal 1/4 binary64) (*.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal 1/4 binary64))))
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(sqrt.f64 (exp.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64)))) (sqrt.f64 (fma.f64 (*.f64 re #s(literal 2 binary64)) (-.f64 (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)) (*.f64 (*.f64 re re) #s(literal 4 binary64)))) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(/.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))) (sqrt.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(/.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/4 binary64)) (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/4 binary64)))
(+.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 re #s(literal 2 binary64)))
(+.f64 (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(-.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))) (/.f64 (*.f64 (*.f64 re re) #s(literal 4 binary64)) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(fma.f64 re #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(fma.f64 #s(literal 2 binary64) re (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(fma.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))) (*.f64 re #s(literal 2 binary64)))
(fma.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64) (*.f64 re #s(literal 2 binary64)))
(fma.f64 (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) (*.f64 re #s(literal 2 binary64)))
(fma.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 re #s(literal 2 binary64)))
(/.f64 #s(literal 2 binary64) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 re #s(literal 2 binary64)) (-.f64 (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64))) (fma.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)) (*.f64 (*.f64 re re) #s(literal 4 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))) (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re) (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (fma.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64))) (fma.f64 (*.f64 re #s(literal 2 binary64)) (-.f64 (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64))))
(/.f64 (fma.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64))) (fma.f64 (*.f64 re re) #s(literal 4 binary64) (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)) (*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (*.f64 #s(literal 2 binary64) (*.f64 re #s(literal 2 binary64)))))))
(/.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)) (*.f64 (*.f64 re re) #s(literal 4 binary64))) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))
(/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))
(/.f64 (neg.f64 (fma.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64)))) (neg.f64 (fma.f64 (*.f64 re #s(literal 2 binary64)) (-.f64 (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)) (*.f64 (*.f64 re re) #s(literal 4 binary64)))) (neg.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))) (-.f64 #s(literal 0 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(/.f64 (-.f64 (*.f64 (*.f64 re re) #s(literal 4 binary64)) (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64))) (-.f64 (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))) (-.f64 #s(literal 0 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 (*.f64 re re) (fma.f64 re re (*.f64 im im)))) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(/.f64 (*.f64 (-.f64 (*.f64 re re) (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64)) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(pow.f64 (/.f64 (fma.f64 (*.f64 re #s(literal 2 binary64)) (-.f64 (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64))) (fma.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)) (*.f64 (*.f64 re re) #s(literal 4 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))) (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re) (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal -1 binary64))
(*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64))
(*.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(*.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 2 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(*.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) #s(literal 2 binary64)))
(*.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(*.f64 (fma.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re #s(literal 2 binary64)) (-.f64 (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)))))
(*.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) #s(literal 4 binary64)) (*.f64 (*.f64 re re) #s(literal 4 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(*.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(*.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) (fma.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))))) (fma.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)) (*.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (-.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) (*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))) (-.f64 (fma.f64 re re (*.f64 im im)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))) (-.f64 (fma.f64 re re (*.f64 im im)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 re (*.f64 re re)))) (fma.f64 re (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (fma.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))))
(hypot.f64 re im)
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 im re)
(hypot.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)))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(fabs.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.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 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.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 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (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 (sqrt.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 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 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) #s(literal 1/8 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (sqrt.f64 (*.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 (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)
(+.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal -1 binary64)))
(-.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(-.f64 (/.f64 (*.f64 re re) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(fma.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(fma.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (/.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(fma.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(fma.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(fma.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) re)
(fma.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)))) re)
(fma.f64 (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (sqrt.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) re)
(fma.f64 (sqrt.f64 re) (sqrt.f64 re) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(fma.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(fma.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 re (*.f64 re re)))) (fma.f64 re (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))))
(neg.f64 (/.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 #s(literal 0 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(/.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))
(/.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (-.f64 (*.f64 re re) (fma.f64 re re (*.f64 im im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 #s(literal 0 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re)) (*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))))) (*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))) (fma.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))))
(/.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))) (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 re (*.f64 re re)))))
(/.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re) (fma.f64 (*.f64 re re) (fma.f64 re re (fma.f64 re re (*.f64 im im))) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 re re) (fma.f64 re re (*.f64 im im))) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 re re (fma.f64 re re (*.f64 im im))) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re) (fma.f64 re re (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
(/.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (*.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re) (*.f64 re re))) (*.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re)) (*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (*.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 re (*.f64 re re))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re re) (fma.f64 re re (fma.f64 re re (*.f64 im im))) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(/.f64 (*.f64 (*.f64 (fma.f64 re re (fma.f64 re re (*.f64 im im))) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re re (fma.f64 re re (*.f64 im im))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(/.f64 (neg.f64 (-.f64 (*.f64 re re) (fma.f64 re re (*.f64 im im)))) (neg.f64 (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) #s(literal 3 binary64)) (*.f64 (*.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))) (fma.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (fma.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (*.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))))
(/.f64 (-.f64 (*.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))) (*.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))) (+.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re)) (*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))) (fma.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))) (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 re (*.f64 re re))))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))) (fma.f64 (*.f64 re re) (fma.f64 re re (fma.f64 re re (*.f64 im im))) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 re re (fma.f64 re re (*.f64 im im))) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))) (fma.f64 re re (fma.f64 re re (*.f64 im im))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (-.f64 (*.f64 re re) (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(*.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(*.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))) (*.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))))
(*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))) (/.f64 (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))))
(*.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)))
(*.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im)))) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re)) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (-.f64 (*.f64 re re) (fma.f64 re re (*.f64 im im))) (/.f64 #s(literal 1 binary64) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 (/.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (fma.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))))) (fma.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)) (*.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (-.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (fma.f64 re re (*.f64 im im))))))
(*.f64 (/.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))) (*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))) (-.f64 (fma.f64 re re (*.f64 im im)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))) (-.f64 (fma.f64 re re (*.f64 im im)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 re (*.f64 re re)))) (fma.f64 re (+.f64 re (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (fma.f64 re re (*.f64 im im))))

simplify499.0ms (5.2%)

Memory
5.2MiB live, 634.4MiB allocated
Algorithm
1×egg-herbie
Rules
10 342×accelerator-lowering-fma.f32
10 342×accelerator-lowering-fma.f64
7 766×*-lowering-*.f32
7 766×*-lowering-*.f64
2 698×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
05003104
116592919
259062897
080792716
Stop Event
1×iter limit
1×node limit
Counts
144 → 144
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))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))))
(* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))
(* re (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))
(* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))
(* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/64 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))))
(* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(+ (* 1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/1024 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))
(+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))))
(+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* -1/4 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/8 (sqrt (/ 1 (pow re 3)))))))
(+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/4 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/4 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(* -1/2 (* (sqrt im) (* (sqrt -1) (sqrt 2))))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))
(* -1 (* im (+ (* -1 (/ (+ (* 1/16 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))
(* (sqrt im) (sqrt 2))
(+ (* 1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))
(+ (* re (+ (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))) (* (sqrt im) (sqrt 2)))
(* (sqrt re) (pow (sqrt 2) 2))
(* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))
(* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))
(* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/32 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))
(* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))
(+ (* 1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/512 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(* (sqrt re) (pow (sqrt 2) 2))
(+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* (sqrt re) (pow (sqrt 2) 2)))
(+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/4 (sqrt (/ 1 (pow re 3)))))))
(+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/2 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))
(* (sqrt im) (sqrt 2))
(* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))
(* -1 (* (sqrt im) (* (sqrt -1) (sqrt 2))))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))
(* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(* -1 (* im (+ (* -1 (/ (+ (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/4 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(* 2 im)
(+ (* 2 im) (* 2 re))
(+ (* 2 im) (* re (+ 2 (/ re im))))
(+ (* 2 im) (* re (+ 2 (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))))))
(* 4 re)
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))))
(* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/8 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))))
(* -1 (/ (pow im 2) re))
(* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re))
(* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re))
(* -1 (/ (+ (* -1 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2)))) re))
(* 4 re)
(+ (* 4 re) (/ (pow im 2) re))
(+ (* 4 re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re))))
(+ (* 4 re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re))))
(* 2 im)
(* im (+ 2 (* 2 (/ re im))))
(* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))
(* im (+ 2 (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2))))))
(* -2 im)
(* -1 (* im (+ 2 (* -2 (/ re im)))))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (pow re 2) im)) (* 2 re)) im)))))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im)) (* 2 re)) im)))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
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 re)
(+ im (* re (+ 1 (* 1/2 (/ re im)))))
(+ im (* re (+ 1 (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
(* 2 re)
(* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1/2 (/ (pow im 2) re))
(* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re))
(* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re))
(* -1 (/ (+ (* -1/2 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2))))) re))
(* 2 re)
(+ (* 1/2 (/ (pow im 2) re)) (* 2 re))
(+ (* 2 re) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ (* 2 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 (/ re im)))
(* im (+ 1 (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im)))))
(* -1 im)
(* -1 (* im (+ 1 (* -1 (/ re im)))))
(* -1 (* im (+ 1 (* -1 (/ (+ re (* -1/2 (/ (pow re 2) im))) im)))))
(* -1 (* im (+ 1 (* -1 (/ (+ re (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im))) im)))))
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))))
(*.f64 re (*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 re (*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 re (*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64))))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 re (*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 re (*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 re (*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64))))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 im (*.f64 im (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 im (*.f64 im (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 im (*.f64 im (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64))))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 im (*.f64 im (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 im (*.f64 im (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 im (*.f64 im (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(fma.f64 re (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/4 binary64))) (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))
(fma.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/16 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal 1/16 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal -1/32 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))
(sqrt.f64 re)
(* re (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) #s(literal 1/8 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (*.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) #s(literal 1/8 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/64 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (fma.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 #s(literal -1/64 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 2 binary64)))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) #s(literal 1/8 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))))
(+ (* 1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 1/2 binary64))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))))))
(+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(-.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))))) (/.f64 (fma.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re))) (*.f64 #s(literal 1/64 binary64) (*.f64 (*.f64 (pow.f64 im #s(literal 5 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal 1/2 binary64)))))) (*.f64 re (*.f64 re re))))
(+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/1024 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(-.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))))) (/.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (fma.f64 #s(literal 1/512 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 5 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (*.f64 #s(literal 1/64 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 1/2 binary64))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 re) #s(literal -1/32 binary64)))) (*.f64 re (*.f64 re re))))
(* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))
(sqrt.f64 re)
(+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))))
(fma.f64 #s(literal 1/8 binary64) (*.f64 (*.f64 im im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (sqrt.f64 re))
(+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* -1/4 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/8 (sqrt (/ 1 (pow re 3)))))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/8 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 (*.f64 im im) #s(literal -1/4 binary64)) (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re))))))) (sqrt.f64 re))
(+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/4 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/4 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/4 binary64) (*.f64 (fma.f64 #s(literal 1/8 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))) (*.f64 re re)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re))))))) (*.f64 #s(literal 1/8 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (sqrt.f64 re))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))
(*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
(* im (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)) (*.f64 (*.f64 (*.f64 re re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/8 binary64))))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(*.f64 im (fma.f64 (*.f64 (*.f64 re re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))))) #s(literal 1/16 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))))
(* -1/2 (* (sqrt im) (* (sqrt -1) (sqrt 2))))
(*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (sqrt.f64 im) #s(literal -1/2 binary64)))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 re (sqrt.f64 #s(literal -1 binary64)))) #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (sqrt.f64 #s(literal -1 binary64)))))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (sqrt.f64 #s(literal -1 binary64))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 re (sqrt.f64 #s(literal -1 binary64)))) #s(literal 1/4 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) #s(literal -1/8 binary64)))))))
(* -1 (* im (+ (* -1 (/ (+ (* 1/16 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))
(*.f64 (fma.f64 #s(literal 1/4 binary64) (*.f64 re (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (sqrt.f64 #s(literal -1 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))))) #s(literal -3/16 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) im))
(* (sqrt im) (sqrt 2))
(*.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)))
(+ (* 1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64))))
(+ (* re (+ (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 re (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/8 binary64))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64))))
(+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 re (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) #s(literal 1/8 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal -1/16 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64))))
(* (sqrt re) (pow (sqrt 2) 2))
(*.f64 #s(literal 2 binary64) (sqrt.f64 re))
(* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))
(*.f64 re (fma.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) #s(literal 1/4 binary64)))))
(* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))
(*.f64 re (fma.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/16 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) #s(literal 1/4 binary64))))))
(* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/32 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/16 binary64) (/.f64 (*.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 2 binary64))) (fma.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) #s(literal 1/4 binary64))))))
(* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 #s(literal -1 binary64)))))
(+ (* 1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(fma.f64 (*.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) #s(literal 1/16 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))))
(+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(-.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))) (/.f64 (fma.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 (pow.f64 im #s(literal 5 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 re) #s(literal -1/16 binary64)))) (*.f64 re (*.f64 re re))))
(+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/512 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(-.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))) (/.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (fma.f64 #s(literal 1/256 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 5 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (*.f64 #s(literal 1/32 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 1/2 binary64))))) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 re) #s(literal -1/16 binary64)))) (*.f64 re (*.f64 re re))))
(* (sqrt re) (pow (sqrt 2) 2))
(*.f64 #s(literal 2 binary64) (sqrt.f64 re))
(+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* (sqrt re) (pow (sqrt 2) 2)))
(fma.f64 #s(literal 2 binary64) (sqrt.f64 re) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) #s(literal 1/4 binary64))))
(+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/4 (sqrt (/ 1 (pow re 3)))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (*.f64 (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1/2 binary64))) (*.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 2 binary64) (sqrt.f64 re)))
(+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/2 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (fma.f64 #s(literal 1/8 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))) (*.f64 re re)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1/2 binary64)))) (*.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 2 binary64) (sqrt.f64 re)))
(* (sqrt im) (sqrt 2))
(*.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)))
(* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))
(*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))
(*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64)) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (*.f64 (*.f64 re re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))
(*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal 1/8 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))))
(* -1 (* (sqrt im) (* (sqrt -1) (sqrt 2))))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64)))))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (sqrt.f64 #s(literal -1 binary64)))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) #s(literal -1/4 binary64)) (fma.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (sqrt.f64 #s(literal -1 binary64))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1 (/ (+ (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/4 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(*.f64 (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 #s(literal -1 binary64))) (fma.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))))) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))))) #s(literal -3/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) im))
(* 2 im)
(*.f64 im #s(literal 2 binary64))
(+ (* 2 im) (* 2 re))
(*.f64 #s(literal 2 binary64) (+.f64 im re))
(+ (* 2 im) (* re (+ 2 (/ re im))))
(fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))
(+ (* 2 im) (* re (+ 2 (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1 binary64) im)) #s(literal 2 binary64)) (*.f64 im #s(literal 2 binary64)))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 4 binary64)))
(* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))))
(*.f64 re (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 4 binary64))))
(* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/8 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))))
(*.f64 re (+.f64 #s(literal 4 binary64) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 im (/.f64 im (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))))))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re))
(/.f64 (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/4 binary64)) (*.f64 re re))) (-.f64 #s(literal 0 binary64) re))
(* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 im im (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/4 binary64)) (*.f64 re re)))) (-.f64 #s(literal 0 binary64) re))
(* -1 (/ (+ (* -1 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2)))) re))
(/.f64 (+.f64 (fma.f64 im im (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (/.f64 (*.f64 (pow.f64 im #s(literal 8 binary64)) #s(literal -5/64 binary64)) (pow.f64 re #s(literal 6 binary64))))) (-.f64 #s(literal 0 binary64) re))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(+ (* 4 re) (/ (pow im 2) re))
(fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))
(+ (* 4 re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 im im) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) re)) (*.f64 re #s(literal 4 binary64)))
(+ (* 4 re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) re)) (*.f64 re #s(literal 4 binary64)))
(* 2 im)
(*.f64 im #s(literal 2 binary64))
(* im (+ 2 (* 2 (/ re im))))
(*.f64 im (fma.f64 #s(literal 2 binary64) (/.f64 re im) #s(literal 2 binary64)))
(* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))
(*.f64 im (fma.f64 #s(literal 2 binary64) (/.f64 re im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 2 binary64))))
(* im (+ 2 (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2))))))
(*.f64 im (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 #s(literal 2 binary64) (/.f64 re im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 2 binary64)))))
(* -2 im)
(*.f64 im #s(literal -2 binary64))
(* -1 (* im (+ 2 (* -2 (/ re im)))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 (/.f64 re im) #s(literal -2 binary64) #s(literal 2 binary64))))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (pow re 2) im)) (* 2 re)) im)))))
(*.f64 (-.f64 #s(literal 2 binary64) (/.f64 (fma.f64 re (-.f64 #s(literal 0 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) re)) im)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im)) (* 2 re)) im)))))
(*.f64 (-.f64 #s(literal 2 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) re) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 im im)) (*.f64 re re)) im)) im)) (-.f64 #s(literal 0 binary64) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 re (*.f64 re (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 re re) (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)))))
(*.f64 re (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64)))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64))))
(* 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/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) (*.f64 re re)))) re)
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(-.f64 #s(literal 0 binary64) (fma.f64 re (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) (*.f64 re re)))) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im im) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) re)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(*.f64 im (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 1 binary64)))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(*.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 1 binary64))))
(* 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/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im im))))) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(*.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(*.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 1 binary64))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(-.f64 #s(literal 0 binary64) (fma.f64 im (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im im))))) im))
im
(+ im re)
(+.f64 im re)
(+ im (* re (+ 1 (* 1/2 (/ re im)))))
(fma.f64 re (fma.f64 #s(literal 1/2 binary64) (/.f64 re im) #s(literal 1 binary64)) im)
(+ im (* re (+ 1 (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) #s(literal 1 binary64)) im)
(* 2 re)
(*.f64 #s(literal 2 binary64) re)
(* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2)))))
(*.f64 re (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 2 binary64)))
(* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 2 binary64))))
(* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 re (+.f64 (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) (*.f64 re re))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal 2 binary64))))
(* -1/2 (/ (pow im 2) re))
(/.f64 (*.f64 (*.f64 im im) #s(literal -1/2 binary64)) re)
(* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re))
(/.f64 (fma.f64 im (*.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal -1/8 binary64)) (*.f64 re re))) (-.f64 #s(literal 0 binary64) re))
(* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re))
(/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (fma.f64 im (*.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (*.f64 re re) (*.f64 re re))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (/ (+ (* -1/2 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2))))) re))
(/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 8 binary64)) #s(literal 5/64 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (fma.f64 im (*.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (*.f64 re re) (*.f64 re re)))))) (-.f64 #s(literal 0 binary64) re))
(* 2 re)
(*.f64 #s(literal 2 binary64) re)
(+ (* 1/2 (/ (pow im 2) re)) (* 2 re))
(fma.f64 #s(literal 2 binary64) re (/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) re))
(+ (* 2 re) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im im) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 #s(literal 2 binary64) re))
(+ (* 2 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 #s(literal 2 binary64) re (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re))))
im
(* im (+ 1 (/ re im)))
(fma.f64 im (/.f64 re im) im)
(* im (+ 1 (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im))))
(fma.f64 im (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 re im)) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im)))))
(fma.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 re im))) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (* -1 (/ re im)))))
(fma.f64 im (/.f64 re im) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 1 (* -1 (/ (+ re (* -1/2 (/ (pow re 2) im))) im)))))
(fma.f64 im (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) re) im) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 1 (* -1 (/ (+ re (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im))) im)))))
(fma.f64 im (/.f64 (-.f64 re (/.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (*.f64 im im))) im)) im) (-.f64 #s(literal 0 binary64) im))

eval59.0ms (0.6%)

Memory
14.8MiB live, 130.3MiB allocated
Compiler

Compiled 14 961 to 2 268 computations (84.8% saved)

prune69.0ms (0.7%)

Memory
-3.1MiB live, 153.3MiB allocated
Pruning

12 alts after pruning (12 fresh and 0 done)

PrunedKeptTotal
New41712429
Fresh000
Picked101
Done000
Total41812430
Accuracy
90.7%
Counts
430 → 12
Alt Table
Click to see full alt table
StatusAccuracyProgram
51.8%
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
▶52.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))))
29.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
29.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
▶13.3%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))))
51.7%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
39.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) re))))
41.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))) re))))
▶5.4%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re))))
41.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
▶54.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
▶29.4%
(sqrt.f64 re)
Compiler

Compiled 338 to 234 computations (30.8% saved)

simplify69.0ms (0.7%)

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

Found 17 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(+.f64 #s(literal 2 binary64) (/.f64 re im))
✓cost-diff0
(fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))
✓cost-diff0
(sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64))))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))))
✓cost-diff0
(/.f64 (*.f64 im im) re)
✓cost-diff0
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
✓cost-diff0
(sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re)))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))))
✓cost-diff0
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re)))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re))))
✓cost-diff320
(*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re))
✓cost-diff384
(+.f64 (-.f64 #s(literal 0 binary64) re) re)
✓cost-diff0
(sqrt.f64 re)
✓cost-diff-64
(*.f64 #s(literal 2 binary64) (+.f64 im re))
✓cost-diff0
(+.f64 im re)
✓cost-diff0
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
Rules
944×accelerator-lowering-fma.f32
944×accelerator-lowering-fma.f64
480×*-lowering-*.f32
480×*-lowering-*.f64
208×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
027159
162129
2109129
3146129
4208129
5258129
6321129
7426129
8606129
9942129
101355129
111518129
121603129
131630129
141642129
01642126
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(* 1/2 (sqrt (* 2 (+ im re))))
1/2
(sqrt (* 2 (+ im re)))
(* 2 (+ im re))
2
(+ im re)
im
re
(sqrt re)
re
(* 1/2 (sqrt (* 2 (+ (- 0 re) re))))
1/2
(sqrt (* 2 (+ (- 0 re) re)))
(* 2 (+ (- 0 re) re))
2
(+ (- 0 re) re)
(- 0 re)
0
re
(* 1/2 (sqrt (- 0 (/ (* im im) re))))
1/2
(sqrt (- 0 (/ (* im im) re)))
(- 0 (/ (* im im) re))
0
(/ (* im im) re)
(* im im)
im
re
(* 1/2 (sqrt (+ (* re (+ 2 (/ re im))) (* im 2))))
1/2
(sqrt (+ (* re (+ 2 (/ re im))) (* im 2)))
(+ (* re (+ 2 (/ re im))) (* im 2))
re
(+ 2 (/ re im))
2
(/ re im)
im
(* im 2)
Outputs
(* 1/2 (sqrt (* 2 (+ im re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 #s(literal 2 binary64) (+.f64 im re) #s(literal 0 binary64))))
1/2
#s(literal 1/2 binary64)
(sqrt (* 2 (+ im re)))
(sqrt.f64 (fma.f64 #s(literal 2 binary64) (+.f64 im re) #s(literal 0 binary64)))
(* 2 (+ im re))
(fma.f64 #s(literal 2 binary64) (+.f64 im re) #s(literal 0 binary64))
2
#s(literal 2 binary64)
(+ im re)
(+.f64 im re)
im
re
(sqrt re)
(sqrt.f64 re)
re
(* 1/2 (sqrt (* 2 (+ (- 0 re) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 0 binary64)))
1/2
#s(literal 1/2 binary64)
(sqrt (* 2 (+ (- 0 re) re)))
(sqrt.f64 #s(literal 0 binary64))
(* 2 (+ (- 0 re) re))
#s(literal 0 binary64)
2
#s(literal 2 binary64)
(+ (- 0 re) re)
#s(literal 0 binary64)
(- 0 re)
(-.f64 #s(literal 0 binary64) re)
0
#s(literal 0 binary64)
re
(* 1/2 (sqrt (- 0 (/ (* im im) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))))
1/2
#s(literal 1/2 binary64)
(sqrt (- 0 (/ (* im im) re)))
(sqrt.f64 (fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64)))
(- 0 (/ (* im im) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
0
#s(literal 0 binary64)
(/ (* im im) re)
(fma.f64 im (/.f64 im re) #s(literal 0 binary64))
(* im im)
(fma.f64 im im #s(literal 0 binary64))
im
re
(* 1/2 (sqrt (+ (* re (+ 2 (/ re im))) (* im 2))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 #s(literal 2 binary64) im (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) #s(literal 0 binary64)))))
1/2
#s(literal 1/2 binary64)
(sqrt (+ (* re (+ 2 (/ re im))) (* im 2)))
(sqrt.f64 (fma.f64 #s(literal 2 binary64) im (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) #s(literal 0 binary64))))
(+ (* re (+ 2 (/ re im))) (* im 2))
(fma.f64 #s(literal 2 binary64) im (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) #s(literal 0 binary64)))
re
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
2
#s(literal 2 binary64)
(/ re im)
(/.f64 re im)
im
(* im 2)
(fma.f64 #s(literal 2 binary64) im #s(literal 0 binary64))

localize131.0ms (1.4%)

Memory
4.2MiB live, 159.8MiB allocated
Localize:

Found 17 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(+.f64 #s(literal 2 binary64) (/.f64 re im))
✓accuracy100.0%
(*.f64 im #s(literal 2 binary64))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))))
✓accuracy100.0%
(sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64))))
✓accuracy100.0%
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
✓accuracy100.0%
(*.f64 im im)
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))))
✓accuracy100.0%
(sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re)))
✓accuracy100.0%
(+.f64 (-.f64 #s(literal 0 binary64) re) re)
✓accuracy100.0%
(*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re))))
✓accuracy100.0%
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re)))
✓accuracy100.0%
(sqrt.f64 re)
✓accuracy100.0%
(+.f64 im re)
✓accuracy100.0%
(*.f64 #s(literal 2 binary64) (+.f64 im re))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
✓accuracy100.0%
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)))
Samples
98.0ms256×0invalid
Compiler

Compiled 154 to 29 computations (81.2% saved)

Precisions
Click to see histograms. Total time spent on operations: 33.0ms
ival-mult: 10.0ms (30.2% of total)
ival-sqrt: 8.0ms (24.2% of total)
ival-sub: 6.0ms (18.1% of total)
ival-add: 5.0ms (15.1% of total)
ival-div: 3.0ms (9.1% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series46.0ms (0.5%)

Memory
10.5MiB live, 59.7MiB allocated
Counts
19 → 372
Calls
Call 1
Inputs
#<alt (* 1/2 (sqrt (* 2 (+ im re))))>
#<alt (sqrt (* 2 (+ im re)))>
#<alt (+ im re)>
#<alt (* 2 (+ im re))>
#<alt (sqrt re)>
#<alt (+ (- 0 re) re)>
#<alt (* 2 (+ (- 0 re) re))>
#<alt (* 1/2 (sqrt (* 2 (+ (- 0 re) re))))>
#<alt (sqrt (* 2 (+ (- 0 re) re)))>
#<alt (* 1/2 (sqrt (- 0 (/ (* im im) re))))>
#<alt (sqrt (- 0 (/ (* im im) re)))>
#<alt (- 0 (/ (* im im) re))>
#<alt (/ (* im im) re)>
#<alt (* 1/2 (sqrt (+ (* re (+ 2 (/ re im))) (* im 2))))>
#<alt (sqrt (+ (* re (+ 2 (/ re im))) (* im 2)))>
#<alt (+ (* re (+ 2 (/ re im))) (* im 2))>
#<alt (+ 2 (/ re im))>
#<alt (* im im)>
#<alt (* im 2)>
Outputs
#<alt (* 1/2 (* (sqrt re) (sqrt 2)))>
#<alt (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (sqrt 2))))>
#<alt (+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* -1/16 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))))))>
#<alt (+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (sqrt 2))) (* 1/32 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 5))))))))))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))>
#<alt (* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))>
#<alt (* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))>
#<alt (* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (sqrt 2)) (pow (sqrt -1) 4)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))) (* 1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))))))))>
#<alt (* 1/2 (* (sqrt re) (sqrt 2)))>
#<alt (* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))>
#<alt (* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))))))>
#<alt (* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (sqrt 2)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))))>
#<alt (* -1/2 (* (sqrt re) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (* -1 (* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))>
#<alt (* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))))>
#<alt (* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))>
#<alt (* (sqrt re) (sqrt 2))>
#<alt (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 re)))) (* (sqrt re) (sqrt 2)))>
#<alt (+ (* im (+ (* -1/8 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))))) (* (sqrt re) (sqrt 2)))>
#<alt (+ (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))) (* im (+ (* -1/8 (* (sqrt (/ 1 (pow re 3))) (sqrt 2))) (* 1/16 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 5))))))))) (* (sqrt re) (sqrt 2)))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))>
#<alt (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* -1 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (sqrt 2)) (pow (sqrt -1) 4)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (+ (* 1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))>
#<alt (+ (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (* (sqrt im) (sqrt 2)))>
#<alt (+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))) (* 1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))))))) (* (sqrt im) (sqrt 2)))>
#<alt (* (sqrt re) (sqrt 2))>
#<alt (* re (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt 2))))>
#<alt (* re (+ (* -1/8 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt 2)))))>
#<alt (* re (+ (* -1/8 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (* (pow im 3) (sqrt 2)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt 2))))))>
#<alt (* -1 (* (sqrt re) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (* -1 (* re (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))>
#<alt (* -1 (* re (+ (* -1/8 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))>
#<alt (* -1 (* re (+ (* -1/8 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))))>
#<alt re>
#<alt (+ im re)>
#<alt (+ im re)>
#<alt (+ im re)>
#<alt im>
#<alt (* im (+ 1 (/ re im)))>
#<alt (* im (+ 1 (/ re im)))>
#<alt (* im (+ 1 (/ re im)))>
#<alt im>
#<alt (* -1 (* im (- (* -1 (/ re im)) 1)))>
#<alt (* -1 (* im (- (* -1 (/ re im)) 1)))>
#<alt (* -1 (* im (- (* -1 (/ re im)) 1)))>
#<alt im>
#<alt (+ im re)>
#<alt (+ im re)>
#<alt (+ im re)>
#<alt re>
#<alt (* re (+ 1 (/ im re)))>
#<alt (* re (+ 1 (/ im re)))>
#<alt (* re (+ 1 (/ im re)))>
#<alt re>
#<alt (* -1 (* re (- (* -1 (/ im re)) 1)))>
#<alt (* -1 (* re (- (* -1 (/ im re)) 1)))>
#<alt (* -1 (* re (- (* -1 (/ im re)) 1)))>
#<alt (* 2 re)>
#<alt (+ (* 2 im) (* 2 re))>
#<alt (+ (* 2 im) (* 2 re))>
#<alt (+ (* 2 im) (* 2 re))>
#<alt (* 2 im)>
#<alt (* im (+ 2 (* 2 (/ re im))))>
#<alt (* im (+ 2 (* 2 (/ re im))))>
#<alt (* im (+ 2 (* 2 (/ re im))))>
#<alt (* 2 im)>
#<alt (* -1 (* im (- (* -2 (/ re im)) 2)))>
#<alt (* -1 (* im (- (* -2 (/ re im)) 2)))>
#<alt (* -1 (* im (- (* -2 (/ re im)) 2)))>
#<alt (* 2 im)>
#<alt (+ (* 2 im) (* 2 re))>
#<alt (+ (* 2 im) (* 2 re))>
#<alt (+ (* 2 im) (* 2 re))>
#<alt (* 2 re)>
#<alt (* re (+ 2 (* 2 (/ im re))))>
#<alt (* re (+ 2 (* 2 (/ im re))))>
#<alt (* re (+ 2 (* 2 (/ im re))))>
#<alt (* 2 re)>
#<alt (* -1 (* re (- (* -2 (/ im re)) 2)))>
#<alt (* -1 (* re (- (* -2 (/ im re)) 2)))>
#<alt (* -1 (* re (- (* -2 (/ im re)) 2)))>
#<alt (sqrt re)>
#<alt (sqrt re)>
#<alt (sqrt re)>
#<alt (sqrt re)>
#<alt (sqrt re)>
#<alt (sqrt re)>
#<alt (sqrt re)>
#<alt (sqrt re)>
#<alt (* -1 (* (sqrt re) (pow (sqrt -1) 2)))>
#<alt (* -1 (* (sqrt re) (pow (sqrt -1) 2)))>
#<alt (* -1 (* (sqrt re) (pow (sqrt -1) 2)))>
#<alt (* -1 (* (sqrt re) (pow (sqrt -1) 2)))>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt 0>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (/ (pow im 2) re)>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 im)) (/ re (sqrt 2)))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2))))) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 (* (pow im 2) (pow (sqrt 2) 4))) (/ 1 (* (pow im 2) (pow (sqrt 2) 2))))) (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (/ (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2)))) (sqrt 2)))))))))>
#<alt (* 1/2 (* (sqrt (/ 1 im)) re))>
#<alt (* re (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re)))))>
#<alt (* re (+ (* 1/4 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re))))))>
#<alt (* re (+ (* -1/4 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) (pow re 3)))) (+ (* 1/4 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re)))))))>
#<alt (* -1/2 (* (sqrt (/ 1 im)) re))>
#<alt (* -1 (* re (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/2 (sqrt im)) (* -1/4 (* (sqrt im) (/ (- (* 2 im) im) re)))) re)) (* 1/2 (sqrt (/ 1 im))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) re))) (* 1/4 (* (sqrt im) (- (* 2 im) im)))) re)) (* -1/2 (sqrt im))) re)) (* 1/2 (sqrt (/ 1 im))))))>
#<alt (* 1/2 (* (sqrt (/ 1 im)) re))>
#<alt (/ (+ (* 1/2 (sqrt (pow im 3))) (* 1/2 (* (sqrt im) re))) im)>
#<alt (/ (+ (* 1/2 (* (sqrt im) re)) (* (pow im 2) (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re)))))) im)>
#<alt (/ (+ (* 1/2 (* (sqrt im) re)) (* (pow im 2) (+ (* 1/2 (sqrt (/ 1 im))) (* im (+ (* -1/4 (* (sqrt (/ 1 im)) (/ 1 re))) (* 1/2 (* (sqrt (/ 1 im)) (/ 1 re)))))))) im)>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* im (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2))))))>
#<alt (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))))))>
#<alt (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2))))))))>
#<alt (* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2)))))))>
#<alt (* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2))))))))>
#<alt (* -1 (* im (+ (* -1 (/ (+ (* -1/4 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (* 1/4 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (pow (sqrt -2) 3))))) (pow im 3))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2))))))))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (+ (* (sqrt im) (sqrt 2)) (* (sqrt (/ 1 im)) (/ re (sqrt 2))))>
#<alt (+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2))))) (sqrt 2)))) (* (sqrt (/ 1 im)) (/ 1 (sqrt 2))))) (* (sqrt im) (sqrt 2)))>
#<alt (+ (* re (+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 (* (pow im 2) (pow (sqrt 2) 4))) (/ 1 (* (pow im 2) (pow (sqrt 2) 2))))) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (/ (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2)))) (sqrt 2)))))) (* (sqrt (/ 1 im)) (/ 1 (sqrt 2))))) (* (sqrt im) (sqrt 2)))>
#<alt (* (sqrt (/ 1 im)) re)>
#<alt (* re (+ (sqrt (/ 1 im)) (* (sqrt im) (/ 1 re))))>
#<alt (* re (+ (sqrt (/ 1 im)) (+ (* 1/2 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (* (sqrt im) (/ 1 re)))))>
#<alt (* re (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) (pow re 3)))) (+ (* 1/2 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (* (sqrt im) (/ 1 re))))))>
#<alt (* -1 (* (sqrt (/ 1 im)) re))>
#<alt (* -1 (* re (+ (sqrt (/ 1 im)) (* (sqrt im) (/ 1 re)))))>
#<alt (* -1 (* re (+ (sqrt (/ 1 im)) (* -1 (/ (+ (* -1 (sqrt im)) (* -1/2 (* (sqrt im) (/ (- (* 2 im) im) re)))) re)))))>
#<alt (* -1 (* re (+ (sqrt (/ 1 im)) (* -1 (/ (+ (* -1 (sqrt im)) (* -1 (/ (+ (* -1/2 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) re))) (* 1/2 (* (sqrt im) (- (* 2 im) im)))) re))) re)))))>
#<alt (* (sqrt (/ 1 im)) re)>
#<alt (/ (+ (sqrt (pow im 3)) (* (sqrt im) re)) im)>
#<alt (/ (+ (* (sqrt im) re) (* (pow im 2) (+ (sqrt (/ 1 im)) (* (sqrt im) (/ 1 re))))) im)>
#<alt (/ (+ (* (sqrt im) re) (* (pow im 2) (+ (sqrt (/ 1 im)) (* im (+ (* -1/2 (* (sqrt (/ 1 im)) (/ 1 re))) (* (sqrt (/ 1 im)) (/ 1 re))))))) im)>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* im (+ (* (sqrt (/ 1 im)) (sqrt 2)) (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))))>
#<alt (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* (sqrt (/ 1 im)) (sqrt 2)) (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2))))))>
#<alt (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* (sqrt (/ 1 im)) (sqrt 2)) (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))))))>
#<alt (* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1 (* im (+ (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2))))))>
#<alt (* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (+ (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2)))))))>
#<alt (* -1 (* im (+ (* -1 (/ (+ (* -1/2 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (* 1/2 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (pow (sqrt -2) 3))))) (pow im 3))) (+ (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2)))))))>
#<alt (* 2 im)>
#<alt (+ (* 2 im) (* 2 re))>
#<alt (+ (* 2 im) (* re (+ 2 (/ re im))))>
#<alt (+ (* 2 im) (* re (+ 2 (/ re im))))>
#<alt (/ (pow re 2) im)>
#<alt (* (pow re 2) (+ (/ 1 im) (* 2 (/ 1 re))))>
#<alt (* (pow re 2) (+ (* 2 (/ im (pow re 2))) (+ (/ 1 im) (* 2 (/ 1 re)))))>
#<alt (* (pow re 2) (+ (* 2 (/ im (pow re 2))) (+ (/ 1 im) (* 2 (/ 1 re)))))>
#<alt (/ (pow re 2) im)>
#<alt (* (pow re 2) (+ (/ 1 im) (* 2 (/ 1 re))))>
#<alt (* (pow re 2) (+ (* -1 (/ (- (* -2 (/ im re)) 2) re)) (/ 1 im)))>
#<alt (* (pow re 2) (+ (* -1 (/ (- (* -2 (/ im re)) 2) re)) (/ 1 im)))>
#<alt (/ (pow re 2) im)>
#<alt (/ (+ (* 2 (* im re)) (pow re 2)) im)>
#<alt (/ (+ (* im (+ (* 2 im) (* 2 re))) (pow re 2)) im)>
#<alt (/ (+ (* im (+ (* 2 im) (* 2 re))) (pow re 2)) im)>
#<alt (* 2 im)>
#<alt (* im (+ 2 (* 2 (/ re im))))>
#<alt (* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))>
#<alt (* 2 im)>
#<alt (* -1 (* im (- (* -2 (/ re im)) 2)))>
#<alt (* -1 (* im (- (* -1 (/ (+ (* 2 re) (/ (pow re 2) im)) im)) 2)))>
#<alt (* -1 (* im (- (* -1 (/ (+ (* 2 re) (/ (pow re 2) im)) im)) 2)))>
#<alt 2>
#<alt (+ 2 (/ re im))>
#<alt (+ 2 (/ re im))>
#<alt (+ 2 (/ re im))>
#<alt (/ re im)>
#<alt (* re (+ (/ 1 im) (* 2 (/ 1 re))))>
#<alt (* re (+ (/ 1 im) (* 2 (/ 1 re))))>
#<alt (* re (+ (/ 1 im) (* 2 (/ 1 re))))>
#<alt (/ re im)>
#<alt (* re (+ (/ 1 im) (* 2 (/ 1 re))))>
#<alt (* re (+ (/ 1 im) (* 2 (/ 1 re))))>
#<alt (* re (+ (/ 1 im) (* 2 (/ 1 re))))>
#<alt (/ re im)>
#<alt (/ (+ re (* 2 im)) im)>
#<alt (/ (+ re (* 2 im)) im)>
#<alt (/ (+ re (* 2 im)) im)>
#<alt 2>
#<alt (+ 2 (/ re im))>
#<alt (+ 2 (/ re im))>
#<alt (+ 2 (/ re im))>
#<alt 2>
#<alt (+ 2 (/ re im))>
#<alt (+ 2 (/ re im))>
#<alt (+ 2 (/ re im))>
#<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)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
Calls

93 calls:

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

rewrite364.0ms (3.8%)

Memory
12.8MiB live, 836.6MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
4 932×accelerator-lowering-fma.f32
4 932×accelerator-lowering-fma.f64
4 698×/-lowering-/.f32
4 698×/-lowering-/.f64
3 806×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
027115
1155103
21355103
08541100
Stop Event
1×iter limit
1×node limit
Counts
19 → 652
Calls
Call 1
Inputs
(* 1/2 (sqrt (* 2 (+ im re))))
(sqrt (* 2 (+ im re)))
(+ im re)
(* 2 (+ im re))
(sqrt re)
(+ (- 0 re) re)
(* 2 (+ (- 0 re) re))
(* 1/2 (sqrt (* 2 (+ (- 0 re) re))))
(sqrt (* 2 (+ (- 0 re) re)))
(* 1/2 (sqrt (- 0 (/ (* im im) re))))
(sqrt (- 0 (/ (* im im) re)))
(- 0 (/ (* im im) re))
(/ (* im im) re)
(* 1/2 (sqrt (+ (* re (+ 2 (/ re im))) (* im 2))))
(sqrt (+ (* re (+ 2 (/ re im))) (* im 2)))
(+ (* re (+ 2 (/ re im))) (* im 2))
(+ 2 (/ re im))
(* im im)
(* im 2)
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 (+.f64 im re)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
(exp.f64 (*.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))) #s(literal 1/2 binary64)))
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)))
(/.f64 (sqrt.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))))) (sqrt.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)))) (sqrt.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))))
(/.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))))) (sqrt.f64 (fma.f64 re (-.f64 re im) (*.f64 im im))))
(/.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (-.f64 im re)))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64))) (sqrt.f64 (fma.f64 re (-.f64 re im) (*.f64 im im))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64))) (sqrt.f64 (-.f64 im re)))
(pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)) (*.f64 #s(literal 2 binary64) (+.f64 im re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (+.f64 im re)))
(*.f64 (sqrt.f64 (+.f64 im re)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)) #s(literal 1/4 binary64)) (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)) #s(literal 1/4 binary64)))
(+.f64 im re)
(+.f64 re im)
(-.f64 (/.f64 (*.f64 im im) (-.f64 im re)) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 im re)))
(-.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 re im)) (/.f64 (*.f64 im im) (-.f64 re im)))
(fma.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 0 binary64) (-.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) im)
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re) im)
(fma.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)) im)
(fma.f64 (*.f64 re #s(literal 1 binary64)) (/.f64 re re) im)
(fma.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)) (/.f64 (-.f64 #s(literal 0 binary64) re) (/.f64 #s(literal 1 binary64) re)) im)
(fma.f64 (/.f64 re (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) re) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) im)
(fma.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) re) re) im)
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) re) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 re (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) im)
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 re (/.f64 #s(literal 1 binary64) re)) im)
(/.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) (fma.f64 re (-.f64 re im) (*.f64 im im)))
(/.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) (fma.f64 re re (-.f64 (*.f64 im im) (*.f64 im re))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 im re)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re re (-.f64 (*.f64 im im) (*.f64 im re))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 re im) (-.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im))))
(/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (-.f64 im re))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re))))
(/.f64 (neg.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 re (-.f64 re im) (*.f64 im im))))
(/.f64 (neg.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 re re (-.f64 (*.f64 im im) (*.f64 im re)))))
(/.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (neg.f64 (-.f64 im re)))
(/.f64 (-.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (-.f64 re im))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (-.f64 im re)) (*.f64 (-.f64 im re) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (-.f64 im re) (-.f64 im re)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))))) (neg.f64 (neg.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (neg.f64 (-.f64 im re))))
(/.f64 (neg.f64 (-.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im))) (neg.f64 (-.f64 re im)))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 im im) (-.f64 im re)) #s(literal 3 binary64)) (pow.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 im re)) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 im im) (-.f64 im re)) (/.f64 (*.f64 im im) (-.f64 im re)) (fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 im re)) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 im re)) (*.f64 (/.f64 (*.f64 im im) (-.f64 im re)) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 im re))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re)) #s(literal -1 binary64))
(*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re im) (*.f64 im im))))
(*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 re re (-.f64 (*.f64 im im) (*.f64 im re)))))
(*.f64 #s(literal 1 binary64) (+.f64 im re))
(*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (-.f64 im re)))
(*.f64 (neg.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)))))
(*.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 im re))))
(*.f64 (-.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 re im)))
(+.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))
(+.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) im))
(-.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))) (/.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))))
(fma.f64 #s(literal 2 binary64) im (*.f64 #s(literal 2 binary64) re))
(fma.f64 #s(literal 2 binary64) re (*.f64 #s(literal 2 binary64) im))
(fma.f64 im #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) re))
(fma.f64 re #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) im))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 im re) (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 im re) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64))))
(/.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))))
(/.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re))) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))
(/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (fma.f64 re (-.f64 re im) (*.f64 im im)))
(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) (-.f64 im re))
(/.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64)) (fma.f64 re (-.f64 re im) (*.f64 im im)))
(/.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64)) (-.f64 im re))
(/.f64 (neg.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))))) (neg.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)))) (neg.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 re (-.f64 re im) (*.f64 im im))))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (-.f64 im re)))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64))) (neg.f64 (fma.f64 re (-.f64 re im) (*.f64 im im))))
(/.f64 (neg.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64))) (neg.f64 (-.f64 im re)))
(/.f64 (fma.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re) (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) im)))))
(*.f64 #s(literal 2 binary64) (+.f64 im re))
(*.f64 (+.f64 im re) #s(literal 2 binary64))
(*.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))))))
(*.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))))
(*.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re im) (*.f64 im im))))
(*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (-.f64 im re)))
(*.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re im) (*.f64 im im))))
(*.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 im re)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 1/2 binary64)))
(sqrt.f64 re)
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (sqrt.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (sqrt.f64 (+.f64 #s(literal 0 binary64) (-.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(pow.f64 re #s(literal 1/2 binary64))
(pow.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 re #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 1/2 binary64))
(*.f64 (pow.f64 re #s(literal 1/4 binary64)) (pow.f64 re #s(literal 1/4 binary64)))
#s(literal 0 binary64)
#s(literal 0 binary64)
#s(literal 0 binary64)
#s(literal 0 binary64)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (sqrt.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))) #s(literal 1/2 binary64))
(exp.f64 (*.f64 (log.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))) #s(literal 1/2 binary64)))
(sqrt.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (neg.f64 (/.f64 re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) (sqrt.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (sqrt.f64 (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))
(/.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (sqrt.f64 re))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (sqrt.f64 (neg.f64 (-.f64 #s(literal 0 binary64) re))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 re (*.f64 im im))))
(/.f64 (sqrt.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (sqrt.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))))) (sqrt.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))
(/.f64 (neg.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(/.f64 (neg.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))))) (neg.f64 (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))))
(pow.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (pow.f64 (/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (pow.f64 (/.f64 re (*.f64 im im)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (sqrt.f64 (/.f64 re (*.f64 im im))))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))))
(*.f64 (pow.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) #s(literal 1/4 binary64)))
(*.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 (neg.f64 (/.f64 im re)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (*.f64 im im) #s(literal 1/2 binary64)) (pow.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1/2 binary64)) (pow.f64 (/.f64 im re) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1/2 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 #s(literal -1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (sqrt.f64 im) (sqrt.f64 (neg.f64 (/.f64 im re))))
(*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(+.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(+.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) #s(literal 0 binary64))
(fabs.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(-.f64 (*.f64 #s(literal 0 binary64) (/.f64 re (*.f64 im im))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) re))) (/.f64 (*.f64 im im) (neg.f64 (-.f64 #s(literal 0 binary64) re))))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (-.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))
(sqrt.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))
(fma.f64 im (neg.f64 (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)) #s(literal 0 binary64))
(fma.f64 (*.f64 im im) (neg.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 re (*.f64 im im)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 im) (sqrt.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (*.f64 (*.f64 im im) (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) im) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) im) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 im im)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) im) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im im)) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) im) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 im im)) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 im re) #s(literal 0 binary64))
(neg.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(/.f64 (*.f64 im im) (-.f64 #s(literal 0 binary64) re))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) re)
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (neg.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))
(/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))))
(/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (neg.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))))
(/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))))
(/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (neg.f64 (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 re (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (/.f64 re (*.f64 im im)) (/.f64 re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 re (-.f64 #s(literal 0 binary64) (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 0 binary64) re) (*.f64 im im)))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) re)) (-.f64 #s(literal 0 binary64) (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 (/.f64 re (*.f64 im im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 re (*.f64 im im)) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 0 binary64) re) (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (-.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 re (*.f64 im im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (neg.f64 (/.f64 re (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))
(/.f64 (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (sqrt.f64 (/.f64 re (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (-.f64 #s(literal 0 binary64) re))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) re))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 im im) (*.f64 im im))) (sqrt.f64 (fma.f64 re re #s(literal 0 binary64))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (sqrt.f64 re))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 im im) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64))) (sqrt.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im))))
(/.f64 (sqrt.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 im im))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(/.f64 (sqrt.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) (/.f64 re (*.f64 im im)))))
(/.f64 (sqrt.f64 (*.f64 #s(literal 1 binary64) (*.f64 im im))) (sqrt.f64 (*.f64 (/.f64 re (*.f64 im im)) re)))
(/.f64 (sqrt.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (sqrt.f64 (*.f64 (/.f64 re (*.f64 im im)) (-.f64 #s(literal 0 binary64) re))))
(/.f64 (sqrt.f64 (+.f64 #s(literal 0 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))))) (sqrt.f64 (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))))))
(/.f64 (sqrt.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))) (sqrt.f64 (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 1 binary64))) (sqrt.f64 (/.f64 re (*.f64 im im))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 im im) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))) (sqrt.f64 re))
(/.f64 (sqrt.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (-.f64 (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (neg.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(/.f64 (fma.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64)) (+.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) #s(literal 0 binary64)))))
(/.f64 (-.f64 (pow.f64 (/.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 3 binary64)) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (fma.f64 (/.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (+.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (/.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 0 binary64) (/.f64 re (*.f64 im im))) #s(literal 3 binary64)) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (fma.f64 (*.f64 #s(literal 0 binary64) (/.f64 re (*.f64 im im))) (*.f64 #s(literal 0 binary64) (/.f64 re (*.f64 im im))) (+.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (*.f64 #s(literal 0 binary64) (/.f64 re (*.f64 im im))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))))
(pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 1/2 binary64))
(pow.f64 (neg.f64 (/.f64 re (*.f64 im im))) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))) #s(literal -1 binary64))
(*.f64 im (neg.f64 (/.f64 im re)))
(*.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)))
(*.f64 (*.f64 im im) (neg.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))))
(*.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 re (*.f64 im im)))
(*.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))))
(*.f64 #s(literal -1 binary64) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (sqrt.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)))
(*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (sqrt.f64 im) (sqrt.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))))
(*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))))
(*.f64 (sqrt.f64 (*.f64 (*.f64 im im) (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im re)))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (*.f64 im (*.f64 im im)) im) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))))
(*.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 im im)) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))))
(*.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im re)))
(*.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) im) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))))
(*.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 im im)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))))
(*.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 im re)))
(*.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) im) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im im)) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im re)))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) im) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))))
(*.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 im im)) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))))
(*.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im)) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (/.f64 im re)))
(*.f64 (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im))) (/.f64 (pow.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 3/2 binary64)) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 im re))
(+.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(+.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 0 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 re (*.f64 im im))) #s(literal -1 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) re) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(-.f64 (*.f64 #s(literal 0 binary64) (/.f64 re (*.f64 im im))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))
(fma.f64 im (/.f64 im re) #s(literal 0 binary64))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 re (*.f64 im im)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 im re) im #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 im im)) #s(literal -1 binary64)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) re #s(literal 0 binary64))
(fma.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (*.f64 im #s(literal 1 binary64)) (/.f64 im re) #s(literal 0 binary64))
(fma.f64 (*.f64 im #s(literal 1 binary64)) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) #s(literal 0 binary64))
(fma.f64 (/.f64 im im) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (*.f64 im im)) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))) #s(literal 0 binary64))
(fma.f64 (/.f64 im (/.f64 im re)) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) im) #s(literal 0 binary64))
(fma.f64 (/.f64 im (/.f64 #s(literal 1 binary64) re)) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (*.f64 im im)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 im (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im im) im) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im im) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im im) (/.f64 im re)) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) im) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re)) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 im im)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im im) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 im im) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 im re)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 1 binary64)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) im) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 im re)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) im) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 im im)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) im) (/.f64 (/.f64 im re) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (*.f64 im im)) (/.f64 (/.f64 im re) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (/.f64 im re) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) #s(literal 1 binary64)) (/.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 im re)) (/.f64 (/.f64 im re) im) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 #s(literal 1 binary64) re)) (/.f64 (/.f64 im re) (*.f64 im im)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 im re) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 im re) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) im) (/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (*.f64 im im)) (/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 im re)) (/.f64 (/.f64 #s(literal 1 binary64) re) im) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)) (/.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im)) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) re) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) re) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) re) #s(literal 0 binary64))
(fma.f64 (/.f64 im (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) im) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(neg.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(/.f64 (*.f64 im im) re)
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) re))
(/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (neg.f64 (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))))
(/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 re (*.f64 im im)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 re (*.f64 (*.f64 im im) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 re (*.f64 im im))))
(/.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) re)
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (neg.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(/.f64 (neg.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64))) (-.f64 #s(literal 0 binary64) re))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) re))))
(/.f64 (fma.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))))
(pow.f64 (/.f64 re (*.f64 im im)) #s(literal -1 binary64))
(*.f64 im (/.f64 im re))
(*.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)))
(*.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))))
(*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 re (*.f64 im im)))
(*.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
(*.f64 (/.f64 im re) im)
(*.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im))
(*.f64 (/.f64 #s(literal 1 binary64) re) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 im im)) #s(literal -1 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64))))
(*.f64 #s(literal -1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) #s(literal 0 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) re)
(*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 im #s(literal 1 binary64)) (/.f64 im re))
(*.f64 (*.f64 im #s(literal 1 binary64)) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)))
(*.f64 (/.f64 im im) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 im re)))
(*.f64 (/.f64 im (*.f64 im im)) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))))
(*.f64 (/.f64 im (/.f64 im re)) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) im))
(*.f64 (/.f64 im (/.f64 #s(literal 1 binary64) re)) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (*.f64 im im)))
(*.f64 (/.f64 im (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64))))
(*.f64 (/.f64 im (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))) re))
(*.f64 (/.f64 (*.f64 im im) im) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im re)))
(*.f64 (/.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (*.f64 im im) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))))
(*.f64 (/.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 im im) (/.f64 im re)) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) im))
(*.f64 (/.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re)) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 im im)))
(*.f64 (/.f64 (*.f64 im im) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 im im) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) re))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 im re)))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 im re)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) #s(literal 1 binary64)) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) im) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im re)))
(*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 im im)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))))
(*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 im re)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) im))
(*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 im im)))
(*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) re))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) im) (/.f64 (/.f64 im re) (/.f64 im re)))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (*.f64 im im)) (/.f64 (/.f64 im re) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (/.f64 im re) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) #s(literal 1 binary64)) (/.f64 (/.f64 im re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 im re)) (/.f64 (/.f64 im re) im))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 #s(literal 1 binary64) re)) (/.f64 (/.f64 im re) (*.f64 im im)))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 im re) (fma.f64 re re #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) im) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 im re) re))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) im) (/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im re)))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (*.f64 im im)) (/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) re) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 im re)) (/.f64 (/.f64 #s(literal 1 binary64) re) im))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)) (/.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im)))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) re) (fma.f64 re re #s(literal 0 binary64))))
(*.f64 (/.f64 (*.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (*.f64 im im)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) re) re))
(*.f64 (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (/.f64 (fma.f64 im (/.f64 im re) #s(literal 0 binary64)) re))
(*.f64 (/.f64 im (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) im) re))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im (/.f64 #s(literal 1 binary64) re)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))))
(*.f64 (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))) #s(literal 1/2 binary64))
(exp.f64 (*.f64 (log.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))) #s(literal 1/2 binary64)))
(sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))))) (sqrt.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (sqrt.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))))))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im))))) (sqrt.f64 (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))))))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im))))) (sqrt.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (*.f64 #s(literal 2 binary64) im)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (neg.f64 (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))))) (sqrt.f64 (neg.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))) (sqrt.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))))) (neg.f64 (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))))
(pow.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))))
(*.f64 (pow.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) #s(literal 1/4 binary64)))
(+.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(+.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 #s(literal 2 binary64) im))
(+.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))
(+.f64 (*.f64 #s(literal 2 binary64) re) (fma.f64 re (/.f64 re im) (*.f64 #s(literal 2 binary64) im)))
(-.f64 (/.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (/.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))))
(-.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))) (/.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))))
(fma.f64 #s(literal 2 binary64) im (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))
(fma.f64 #s(literal 2 binary64) re (fma.f64 re (/.f64 re im) (*.f64 #s(literal 2 binary64) im)))
(fma.f64 #s(literal 2 binary64) (+.f64 im re) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(fma.f64 im #s(literal 2 binary64) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))
(fma.f64 re #s(literal 2 binary64) (fma.f64 re (/.f64 re im) (*.f64 #s(literal 2 binary64) im)))
(fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))
(fma.f64 (+.f64 im re) #s(literal 2 binary64) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(fma.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) re (*.f64 #s(literal 2 binary64) im))
(fma.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))))) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(fma.f64 (fma.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (/.f64 (*.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re) (-.f64 (*.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) im) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im)) (*.f64 (*.f64 #s(literal 2 binary64) re) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))))) (*.f64 #s(literal 2 binary64) im))
(fma.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re))) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(fma.f64 (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) im) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal 2 binary64) re) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))) (*.f64 #s(literal 2 binary64) im))
(fma.f64 (*.f64 re (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (-.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 4 binary64))) (*.f64 #s(literal 2 binary64) im))
(fma.f64 (*.f64 re (-.f64 #s(literal 4 binary64) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 #s(literal 2 binary64) im))
(fma.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re im) (*.f64 im im))) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(fma.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (-.f64 im re)) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(fma.f64 (*.f64 (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im)))) re) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (-.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 4 binary64))) (*.f64 #s(literal 2 binary64) im))
(fma.f64 (*.f64 (-.f64 #s(literal 4 binary64) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im))) re) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 #s(literal 2 binary64) im))
(fma.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re im) (*.f64 im im))) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(fma.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 im re)) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(/.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))))
(/.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (*.f64 #s(literal 2 binary64) im))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (*.f64 #s(literal 2 binary64) im))))) (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))))
(/.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)))))
(/.f64 (neg.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (*.f64 #s(literal 2 binary64) im)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))) (neg.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))))
(/.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))
(/.f64 (fma.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 im re) (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) re)) (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) (/.f64 im re)))
(/.f64 (fma.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) im (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) im))
(/.f64 (fma.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (-.f64 #s(literal 0 binary64) im) (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) (-.f64 #s(literal 0 binary64) im)))
(/.f64 (fma.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 im re) (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) (*.f64 re #s(literal 1 binary64)))) (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) (/.f64 im re)))
(/.f64 (fma.f64 (fma.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)) (*.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))))) (/.f64 im re) (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) (*.f64 #s(literal 1 binary64) re))) (*.f64 (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)))) (/.f64 im re)))
(/.f64 (fma.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re))) (/.f64 im re) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) re)) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) (/.f64 im re)))
(/.f64 (fma.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re))) im (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) im))
(/.f64 (fma.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re))) (-.f64 #s(literal 0 binary64) im) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) (-.f64 #s(literal 0 binary64) im)))
(/.f64 (fma.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re))) (/.f64 im re) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) (*.f64 re #s(literal 1 binary64)))) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) (/.f64 im re)))
(/.f64 (fma.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re))) (/.f64 im re) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) (*.f64 #s(literal 1 binary64) re))) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) re)) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 im re) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) re)) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) im (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) im))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) im) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (-.f64 #s(literal 0 binary64) im)))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 im re) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (*.f64 re #s(literal 1 binary64)))) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 im re) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (*.f64 #s(literal 1 binary64) re))) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 im re) (*.f64 (-.f64 im re) re)) (*.f64 (-.f64 im re) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) im (*.f64 (-.f64 im re) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (-.f64 im re) im))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) (-.f64 #s(literal 0 binary64) im) (*.f64 (-.f64 im re) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (*.f64 (-.f64 im re) (-.f64 #s(literal 0 binary64) im)))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 im re) (*.f64 (-.f64 im re) (*.f64 re #s(literal 1 binary64)))) (*.f64 (-.f64 im re) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 #s(literal 2 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 im re) (*.f64 (-.f64 im re) (*.f64 #s(literal 1 binary64) re))) (*.f64 (-.f64 im re) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64)) (/.f64 im re) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) re)) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64)) im (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) im))
(/.f64 (fma.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) im) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (-.f64 #s(literal 0 binary64) im)))
(/.f64 (fma.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64)) (/.f64 im re) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (*.f64 re #s(literal 1 binary64)))) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) (*.f64 im (*.f64 im im))) #s(literal 2 binary64)) (/.f64 im re) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (*.f64 #s(literal 1 binary64) re))) (*.f64 (fma.f64 re (-.f64 re im) (*.f64 im im)) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64)) (/.f64 im re) (*.f64 (-.f64 im re) re)) (*.f64 (-.f64 im re) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64)) im (*.f64 (-.f64 im re) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (-.f64 im re) im))
(/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) im) (*.f64 (-.f64 im re) (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))))) (*.f64 (-.f64 im re) (-.f64 #s(literal 0 binary64) im)))
(/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64)) (/.f64 im re) (*.f64 (-.f64 im re) (*.f64 re #s(literal 1 binary64)))) (*.f64 (-.f64 im re) (/.f64 im re)))
(/.f64 (fma.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 2 binary64)) (/.f64 im re) (*.f64 (-.f64 im re) (*.f64 #s(literal 1 binary64) re))) (*.f64 (-.f64 im re) (/.f64 im re)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)) (*.f64 (*.f64 im im) #s(literal 4 binary64)))) (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)))))) (neg.f64 (neg.f64 (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))))) (neg.f64 (neg.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))) (neg.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))))
(/.f64 (+.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)) #s(literal 3 binary64)) (/.f64 (*.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 re (fma.f64 re re #s(literal 0 binary64)))) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)) (*.f64 #s(literal 2 binary64) (+.f64 im re)) (-.f64 (*.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) im) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im)) (*.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)) (/.f64 (fma.f64 re re #s(literal 0 binary64)) im)))))
(/.f64 (fma.f64 #s(literal 8 binary64) (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (pow.f64 (fma.f64 re (/.f64 re im) (*.f64 #s(literal 2 binary64) im)) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) re) (-.f64 (*.f64 (fma.f64 re (/.f64 re im) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (/.f64 re im) (*.f64 #s(literal 2 binary64) im))) (*.f64 (*.f64 #s(literal 2 binary64) re) (fma.f64 re (/.f64 re im) (*.f64 #s(literal 2 binary64) im))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (/.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (/.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (*.f64 (/.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (/.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))) #s(literal -1 binary64))
(*.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))))))
(*.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (*.f64 #s(literal 2 binary64) im)))))))
(*.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)))
(*.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im))))
(*.f64 (neg.f64 (fma.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 #s(literal 8 binary64) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (*.f64 (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))) (*.f64 (*.f64 #s(literal 2 binary64) im) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))))))))
(*.f64 (neg.f64 (*.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im)) (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal -2 binary64) im)))))
(*.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))))))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(+.f64 (/.f64 re im) #s(literal 2 binary64))
(-.f64 (/.f64 #s(literal 4 binary64) (-.f64 #s(literal 2 binary64) (/.f64 re im))) (/.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (-.f64 #s(literal 2 binary64) (/.f64 re im))))
(-.f64 (/.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (-.f64 (/.f64 re im) #s(literal 2 binary64))) (/.f64 #s(literal 4 binary64) (-.f64 (/.f64 re im) #s(literal 2 binary64))))
(fma.f64 re (/.f64 #s(literal 1 binary64) im) #s(literal 2 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) re) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) #s(literal 2 binary64))
(fma.f64 (/.f64 re im) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 2 binary64))
(fma.f64 (/.f64 re im) (/.f64 re re) #s(literal 2 binary64))
(fma.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 2 binary64))
(fma.f64 #s(literal 1 binary64) (/.f64 re im) #s(literal 2 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) im) re #s(literal 2 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) im) (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1 binary64)) #s(literal 2 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 #s(literal 0 binary64) im) re)) #s(literal 2 binary64))
(fma.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 im re))) #s(literal 2 binary64))
(fma.f64 (*.f64 re #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) im) #s(literal 2 binary64))
(fma.f64 (neg.f64 (-.f64 #s(literal 0 binary64) re)) (/.f64 #s(literal 1 binary64) im) #s(literal 2 binary64))
(fma.f64 (/.f64 re (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 #s(literal 0 binary64) re) re) #s(literal 2 binary64))
(fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)) #s(literal 2 binary64))
(fma.f64 (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) im) #s(literal 2 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal -1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) re) im) #s(literal 2 binary64))
(fma.f64 (/.f64 (pow.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 3/2 binary64)) (-.f64 #s(literal 0 binary64) im)) (/.f64 (pow.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 3/2 binary64)) (fma.f64 re re #s(literal 0 binary64))) #s(literal 2 binary64))
(/.f64 (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im)))) (fma.f64 (/.f64 re im) (-.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 4 binary64)))
(/.f64 (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im)))) (fma.f64 re (/.f64 re (*.f64 im im)) (-.f64 #s(literal 4 binary64) (/.f64 (*.f64 #s(literal 2 binary64) re) im))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 2 binary64) (/.f64 re im))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (/.f64 re (*.f64 im im)) (-.f64 #s(literal 4 binary64) (/.f64 (*.f64 #s(literal 2 binary64) re) im))) (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 2 binary64) (/.f64 re im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (/.f64 re im) #s(literal 2 binary64)) (-.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) #s(literal 4 binary64))))
(/.f64 (-.f64 #s(literal 4 binary64) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im))) (-.f64 #s(literal 2 binary64) (/.f64 re im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 2 binary64) (/.f64 re im)))))
(/.f64 (neg.f64 (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 (/.f64 re im) (-.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 4 binary64))))
(/.f64 (neg.f64 (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 re (/.f64 re (*.f64 im im)) (-.f64 #s(literal 4 binary64) (/.f64 (*.f64 #s(literal 2 binary64) re) im)))))
(/.f64 (neg.f64 (-.f64 #s(literal 4 binary64) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)))) (neg.f64 (-.f64 #s(literal 2 binary64) (/.f64 re im))))
(/.f64 (-.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) #s(literal 4 binary64)) (-.f64 (/.f64 re im) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 4 binary64) (-.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (-.f64 #s(literal 2 binary64) (/.f64 re im)) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)))) (*.f64 (-.f64 #s(literal 2 binary64) (/.f64 re im)) (-.f64 #s(literal 2 binary64) (/.f64 re im))))
(/.f64 (neg.f64 (neg.f64 (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im)))))) (neg.f64 (neg.f64 (fma.f64 (/.f64 re im) (-.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 4 binary64)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 4 binary64) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im))))) (neg.f64 (neg.f64 (-.f64 #s(literal 2 binary64) (/.f64 re im)))))
(/.f64 (neg.f64 (-.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) #s(literal 4 binary64))) (neg.f64 (-.f64 (/.f64 re im) #s(literal 2 binary64))))
(/.f64 (-.f64 (pow.f64 (/.f64 #s(literal 4 binary64) (-.f64 #s(literal 2 binary64) (/.f64 re im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (-.f64 #s(literal 2 binary64) (/.f64 re im))) #s(literal 3 binary64))) (fma.f64 (/.f64 #s(literal 4 binary64) (-.f64 #s(literal 2 binary64) (/.f64 re im))) (/.f64 #s(literal 4 binary64) (-.f64 #s(literal 2 binary64) (/.f64 re im))) (fma.f64 (/.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (-.f64 #s(literal 2 binary64) (/.f64 re im))) (/.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (-.f64 #s(literal 2 binary64) (/.f64 re im))) (*.f64 (/.f64 #s(literal 4 binary64) (-.f64 #s(literal 2 binary64) (/.f64 re im))) (/.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (-.f64 #s(literal 2 binary64) (/.f64 re im)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 2 binary64) (/.f64 re im))) #s(literal -1 binary64))
(*.f64 (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (-.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 4 binary64))))
(*.f64 (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im im)) (-.f64 #s(literal 4 binary64) (/.f64 (*.f64 #s(literal 2 binary64) re) im)))))
(*.f64 #s(literal 1 binary64) (+.f64 #s(literal 2 binary64) (/.f64 re im)))
(*.f64 (-.f64 #s(literal 4 binary64) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 2 binary64) (/.f64 re im))))
(*.f64 (neg.f64 (+.f64 #s(literal 8 binary64) (/.f64 (*.f64 re (fma.f64 re re #s(literal 0 binary64))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (/.f64 re im) (-.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 4 binary64)))))
(*.f64 (neg.f64 (-.f64 #s(literal 4 binary64) (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 #s(literal 2 binary64) (/.f64 re im)))))
(*.f64 (-.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (/.f64 re im) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 2 binary64))
(*.f64 im im)
(*.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) im))
(*.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)))
(*.f64 #s(literal 2 binary64) im)
(*.f64 im #s(literal 2 binary64))

simplify561.0ms (5.8%)

Memory
18.8MiB live, 965.3MiB allocated
Algorithm
1×egg-herbie
Rules
13 458×accelerator-lowering-fma.f32
13 458×accelerator-lowering-fma.f64
8 356×*-lowering-*.f32
8 356×*-lowering-*.f64
3 378×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
05354466
118364303
265074260
082244091
Stop Event
1×iter limit
1×node limit
Counts
372 → 372
Calls
Call 1
Inputs
(* 1/2 (* (sqrt re) (sqrt 2)))
(+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (sqrt 2))))
(+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* -1/16 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))))))
(+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (sqrt 2))) (* 1/32 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 5))))))))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (sqrt 2)) (pow (sqrt -1) 4)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))) (* 1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))))))))
(* 1/2 (* (sqrt re) (sqrt 2)))
(* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))
(* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))))))
(* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (sqrt 2)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))))
(* -1/2 (* (sqrt re) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1 (* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))
(* (sqrt re) (sqrt 2))
(+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 re)))) (* (sqrt re) (sqrt 2)))
(+ (* im (+ (* -1/8 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))))) (* (sqrt re) (sqrt 2)))
(+ (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))) (* im (+ (* -1/8 (* (sqrt (/ 1 (pow re 3))) (sqrt 2))) (* 1/16 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 5))))))))) (* (sqrt re) (sqrt 2)))
(* (sqrt im) (sqrt 2))
(* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))
(* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))
(* -1 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (sqrt 2)) (pow (sqrt -1) 4)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(* (sqrt im) (sqrt 2))
(+ (* 1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))
(+ (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))) (* 1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))))))) (* (sqrt im) (sqrt 2)))
(* (sqrt re) (sqrt 2))
(* re (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt 2))))
(* re (+ (* -1/8 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt 2)))))
(* re (+ (* -1/8 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (* (pow im 3) (sqrt 2)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt 2))))))
(* -1 (* (sqrt re) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1 (* re (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))
(* -1 (* re (+ (* -1/8 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(* -1 (* re (+ (* -1/8 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
re
(+ im re)
(+ im re)
(+ im re)
im
(* im (+ 1 (/ re im)))
(* im (+ 1 (/ re im)))
(* im (+ 1 (/ re im)))
im
(* -1 (* im (- (* -1 (/ re im)) 1)))
(* -1 (* im (- (* -1 (/ re im)) 1)))
(* -1 (* im (- (* -1 (/ re im)) 1)))
im
(+ im re)
(+ im re)
(+ im re)
re
(* re (+ 1 (/ im re)))
(* re (+ 1 (/ im re)))
(* re (+ 1 (/ im re)))
re
(* -1 (* re (- (* -1 (/ im re)) 1)))
(* -1 (* re (- (* -1 (/ im re)) 1)))
(* -1 (* re (- (* -1 (/ im re)) 1)))
(* 2 re)
(+ (* 2 im) (* 2 re))
(+ (* 2 im) (* 2 re))
(+ (* 2 im) (* 2 re))
(* 2 im)
(* im (+ 2 (* 2 (/ re im))))
(* im (+ 2 (* 2 (/ re im))))
(* im (+ 2 (* 2 (/ re im))))
(* 2 im)
(* -1 (* im (- (* -2 (/ re im)) 2)))
(* -1 (* im (- (* -2 (/ re im)) 2)))
(* -1 (* im (- (* -2 (/ re im)) 2)))
(* 2 im)
(+ (* 2 im) (* 2 re))
(+ (* 2 im) (* 2 re))
(+ (* 2 im) (* 2 re))
(* 2 re)
(* re (+ 2 (* 2 (/ im re))))
(* re (+ 2 (* 2 (/ im re))))
(* re (+ 2 (* 2 (/ im re))))
(* 2 re)
(* -1 (* re (- (* -2 (/ im re)) 2)))
(* -1 (* re (- (* -2 (/ im re)) 2)))
(* -1 (* re (- (* -2 (/ im re)) 2)))
(sqrt re)
(sqrt re)
(sqrt re)
(sqrt re)
(sqrt re)
(sqrt re)
(sqrt re)
(sqrt re)
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(/ (pow im 2) re)
(* 1/2 (* (sqrt im) (sqrt 2)))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 im)) (/ re (sqrt 2)))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2))))) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 (* (pow im 2) (pow (sqrt 2) 4))) (/ 1 (* (pow im 2) (pow (sqrt 2) 2))))) (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (/ (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2)))) (sqrt 2)))))))))
(* 1/2 (* (sqrt (/ 1 im)) re))
(* re (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re)))))
(* re (+ (* 1/4 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re))))))
(* re (+ (* -1/4 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) (pow re 3)))) (+ (* 1/4 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re)))))))
(* -1/2 (* (sqrt (/ 1 im)) re))
(* -1 (* re (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1/2 (sqrt im)) (* -1/4 (* (sqrt im) (/ (- (* 2 im) im) re)))) re)) (* 1/2 (sqrt (/ 1 im))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) re))) (* 1/4 (* (sqrt im) (- (* 2 im) im)))) re)) (* -1/2 (sqrt im))) re)) (* 1/2 (sqrt (/ 1 im))))))
(* 1/2 (* (sqrt (/ 1 im)) re))
(/ (+ (* 1/2 (sqrt (pow im 3))) (* 1/2 (* (sqrt im) re))) im)
(/ (+ (* 1/2 (* (sqrt im) re)) (* (pow im 2) (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re)))))) im)
(/ (+ (* 1/2 (* (sqrt im) re)) (* (pow im 2) (+ (* 1/2 (sqrt (/ 1 im))) (* im (+ (* -1/4 (* (sqrt (/ 1 im)) (/ 1 re))) (* 1/2 (* (sqrt (/ 1 im)) (/ 1 re)))))))) im)
(* 1/2 (* (sqrt im) (sqrt 2)))
(* im (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2))))))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2))))))))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2)))))))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2))))))))
(* -1 (* im (+ (* -1 (/ (+ (* -1/4 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (* 1/4 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (pow (sqrt -2) 3))))) (pow im 3))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2))))))))
(* (sqrt im) (sqrt 2))
(+ (* (sqrt im) (sqrt 2)) (* (sqrt (/ 1 im)) (/ re (sqrt 2))))
(+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2))))) (sqrt 2)))) (* (sqrt (/ 1 im)) (/ 1 (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(+ (* re (+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 (* (pow im 2) (pow (sqrt 2) 4))) (/ 1 (* (pow im 2) (pow (sqrt 2) 2))))) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (/ (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2)))) (sqrt 2)))))) (* (sqrt (/ 1 im)) (/ 1 (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(* (sqrt (/ 1 im)) re)
(* re (+ (sqrt (/ 1 im)) (* (sqrt im) (/ 1 re))))
(* re (+ (sqrt (/ 1 im)) (+ (* 1/2 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (* (sqrt im) (/ 1 re)))))
(* re (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) (pow re 3)))) (+ (* 1/2 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (* (sqrt im) (/ 1 re))))))
(* -1 (* (sqrt (/ 1 im)) re))
(* -1 (* re (+ (sqrt (/ 1 im)) (* (sqrt im) (/ 1 re)))))
(* -1 (* re (+ (sqrt (/ 1 im)) (* -1 (/ (+ (* -1 (sqrt im)) (* -1/2 (* (sqrt im) (/ (- (* 2 im) im) re)))) re)))))
(* -1 (* re (+ (sqrt (/ 1 im)) (* -1 (/ (+ (* -1 (sqrt im)) (* -1 (/ (+ (* -1/2 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) re))) (* 1/2 (* (sqrt im) (- (* 2 im) im)))) re))) re)))))
(* (sqrt (/ 1 im)) re)
(/ (+ (sqrt (pow im 3)) (* (sqrt im) re)) im)
(/ (+ (* (sqrt im) re) (* (pow im 2) (+ (sqrt (/ 1 im)) (* (sqrt im) (/ 1 re))))) im)
(/ (+ (* (sqrt im) re) (* (pow im 2) (+ (sqrt (/ 1 im)) (* im (+ (* -1/2 (* (sqrt (/ 1 im)) (/ 1 re))) (* (sqrt (/ 1 im)) (/ 1 re))))))) im)
(* (sqrt im) (sqrt 2))
(* im (+ (* (sqrt (/ 1 im)) (sqrt 2)) (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))))
(* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* (sqrt (/ 1 im)) (sqrt 2)) (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2))))))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* (sqrt (/ 1 im)) (sqrt 2)) (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))))))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* -1 (* im (+ (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2))))))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (+ (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2)))))))
(* -1 (* im (+ (* -1 (/ (+ (* -1/2 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (* 1/2 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (pow (sqrt -2) 3))))) (pow im 3))) (+ (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2)))))))
(* 2 im)
(+ (* 2 im) (* 2 re))
(+ (* 2 im) (* re (+ 2 (/ re im))))
(+ (* 2 im) (* re (+ 2 (/ re im))))
(/ (pow re 2) im)
(* (pow re 2) (+ (/ 1 im) (* 2 (/ 1 re))))
(* (pow re 2) (+ (* 2 (/ im (pow re 2))) (+ (/ 1 im) (* 2 (/ 1 re)))))
(* (pow re 2) (+ (* 2 (/ im (pow re 2))) (+ (/ 1 im) (* 2 (/ 1 re)))))
(/ (pow re 2) im)
(* (pow re 2) (+ (/ 1 im) (* 2 (/ 1 re))))
(* (pow re 2) (+ (* -1 (/ (- (* -2 (/ im re)) 2) re)) (/ 1 im)))
(* (pow re 2) (+ (* -1 (/ (- (* -2 (/ im re)) 2) re)) (/ 1 im)))
(/ (pow re 2) im)
(/ (+ (* 2 (* im re)) (pow re 2)) im)
(/ (+ (* im (+ (* 2 im) (* 2 re))) (pow re 2)) im)
(/ (+ (* im (+ (* 2 im) (* 2 re))) (pow re 2)) im)
(* 2 im)
(* im (+ 2 (* 2 (/ re im))))
(* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))
(* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))
(* 2 im)
(* -1 (* im (- (* -2 (/ re im)) 2)))
(* -1 (* im (- (* -1 (/ (+ (* 2 re) (/ (pow re 2) im)) im)) 2)))
(* -1 (* im (- (* -1 (/ (+ (* 2 re) (/ (pow re 2) im)) im)) 2)))
2
(+ 2 (/ re im))
(+ 2 (/ re im))
(+ 2 (/ re im))
(/ re im)
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(/ re im)
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(/ re im)
(/ (+ re (* 2 im)) im)
(/ (+ re (* 2 im)) im)
(/ (+ re (* 2 im)) im)
2
(+ 2 (/ re im))
(+ 2 (/ re im))
(+ 2 (/ re im))
2
(+ 2 (/ re im))
(+ 2 (/ re im))
(+ 2 (/ re im))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
Outputs
(* 1/2 (* (sqrt re) (sqrt 2)))
(*.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (sqrt 2))))
(fma.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/4 binary64))))
(+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* -1/16 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 2 binary64))) (*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/4 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal -1/16 binary64))))))
(+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (sqrt 2))) (* 1/32 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 5))))))))))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/32 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (*.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64)))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal -1/16 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64))))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(*.f64 im (fma.f64 #s(literal 1/32 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (*.f64 re (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal -1/16 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64)))))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 (sqrt.f64 im) (*.f64 #s(literal -1/2 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64)))))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(*.f64 (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal -1 binary64))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (sqrt 2)) (pow (sqrt -1) 4)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))
(*.f64 (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal -1 binary64))) (fma.f64 #s(literal 1/2 binary64) (neg.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64)) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64))))) #s(literal 1/32 binary64))) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)))
(+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/4 binary64))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))
(fma.f64 re (fma.f64 re (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1/16 binary64))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/4 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))) (* 1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))))))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)) (*.f64 re (fma.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/32 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1/16 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/4 binary64))))))
(* 1/2 (* (sqrt re) (sqrt 2)))
(*.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/4 binary64)))))
(* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im)) #s(literal -1/16 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/4 binary64))))))
(* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (sqrt 2)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (*.f64 (*.f64 im (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im))) #s(literal 1/32 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im)) #s(literal -1/16 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/4 binary64)))))))
(* -1/2 (* (sqrt re) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 (sqrt.f64 re) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))) #s(literal -1/2 binary64)))
(* -1 (* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/4 binary64)))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64)) (fma.f64 #s(literal -1/16 binary64) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im))) #s(literal -1 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/4 binary64)))))))
(* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))
(*.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/32 binary64) (*.f64 im (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im)))) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64)) (fma.f64 #s(literal -1/16 binary64) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im))) #s(literal -1 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/4 binary64)))))) (-.f64 #s(literal 0 binary64) re))
(* (sqrt re) (sqrt 2))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 2 binary64)))
(+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 re)))) (* (sqrt re) (sqrt 2)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 2 binary64))))
(+ (* im (+ (* -1/8 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))))) (* (sqrt re) (sqrt 2)))
(fma.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)) (*.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 2 binary64))))
(+ (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))) (* im (+ (* -1/8 (* (sqrt (/ 1 (pow re 3))) (sqrt 2))) (* 1/16 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 5))))))))) (* (sqrt re) (sqrt 2)))
(fma.f64 im (fma.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/16 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1/8 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 2 binary64))))
(* (sqrt im) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))
(*.f64 im (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))
(*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal -1/8 binary64)) (fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))))
(* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))
(*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal -1/8 binary64)) (fma.f64 #s(literal 1/2 binary64) (*.f64 re (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))))) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 re (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))))))))
(* -1 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64)) (neg.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (/.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal -1 binary64)) #s(literal -1/8 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64)) (neg.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (sqrt 2)) (pow (sqrt -1) 4)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (/.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal -1 binary64)) #s(literal -1/8 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64))))) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64))) #s(literal 1/16 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64)) (neg.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))))) (-.f64 #s(literal 0 binary64) im))
(* (sqrt im) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(+ (* 1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 #s(literal 2 binary64))))))
(+ (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal -1/8 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))) (* 1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/16 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1/8 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* (sqrt re) (sqrt 2))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 2 binary64)))
(* re (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt 2))))
(*.f64 re (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/2 binary64)))))
(* re (+ (* -1/8 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt 2)))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im)) #s(literal -1/8 binary64)) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/2 binary64))))))
(* re (+ (* -1/8 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (* (pow im 3) (sqrt 2)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt 2))))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (*.f64 (*.f64 im (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im))) #s(literal 1/16 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im)) #s(literal -1/8 binary64)) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/2 binary64)))))))
(* -1 (* (sqrt re) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* re (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/8 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(*.f64 (fma.f64 (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 im (*.f64 (sqrt.f64 #s(literal 2 binary64)) im))) #s(literal -1 binary64)) #s(literal -1/8 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/2 binary64))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/8 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(*.f64 (fma.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 im im)) (/.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (fma.f64 (*.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 im (*.f64 im im))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) #s(literal 1/2 binary64)))))) (-.f64 #s(literal 0 binary64) re))
re
(+ im re)
(+.f64 re im)
(+ im re)
(+.f64 re im)
(+ im re)
(+.f64 re im)
im
(* im (+ 1 (/ re im)))
(fma.f64 im (/.f64 re im) im)
(* im (+ 1 (/ re im)))
(fma.f64 im (/.f64 re im) im)
(* im (+ 1 (/ re im)))
(fma.f64 im (/.f64 re im) im)
im
(* -1 (* im (- (* -1 (/ re im)) 1)))
(*.f64 im (-.f64 #s(literal 0 binary64) (-.f64 #s(literal -1 binary64) (/.f64 re im))))
(* -1 (* im (- (* -1 (/ re im)) 1)))
(*.f64 im (-.f64 #s(literal 0 binary64) (-.f64 #s(literal -1 binary64) (/.f64 re im))))
(* -1 (* im (- (* -1 (/ re im)) 1)))
(*.f64 im (-.f64 #s(literal 0 binary64) (-.f64 #s(literal -1 binary64) (/.f64 re im))))
im
(+ im re)
(+.f64 re im)
(+ im re)
(+.f64 re im)
(+ im re)
(+.f64 re im)
re
(* re (+ 1 (/ im re)))
(fma.f64 re (/.f64 im re) re)
(* re (+ 1 (/ im re)))
(fma.f64 re (/.f64 im re) re)
(* re (+ 1 (/ im re)))
(fma.f64 re (/.f64 im re) re)
re
(* -1 (* re (- (* -1 (/ im re)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 im re)) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (- (* -1 (/ im re)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 im re)) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (- (* -1 (/ im re)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 im re)) (-.f64 #s(literal 0 binary64) re))
(* 2 re)
(*.f64 re #s(literal 2 binary64))
(+ (* 2 im) (* 2 re))
(*.f64 #s(literal 2 binary64) (+.f64 re im))
(+ (* 2 im) (* 2 re))
(*.f64 #s(literal 2 binary64) (+.f64 re im))
(+ (* 2 im) (* 2 re))
(*.f64 #s(literal 2 binary64) (+.f64 re im))
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* im (+ 2 (* 2 (/ re im))))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) #s(literal 2 binary64)))
(* im (+ 2 (* 2 (/ re im))))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) #s(literal 2 binary64)))
(* im (+ 2 (* 2 (/ re im))))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) #s(literal 2 binary64)))
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* -1 (* im (- (* -2 (/ re im)) 2)))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) #s(literal 2 binary64)))
(* -1 (* im (- (* -2 (/ re im)) 2)))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) #s(literal 2 binary64)))
(* -1 (* im (- (* -2 (/ re im)) 2)))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) #s(literal 2 binary64)))
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(+ (* 2 im) (* 2 re))
(*.f64 #s(literal 2 binary64) (+.f64 re im))
(+ (* 2 im) (* 2 re))
(*.f64 #s(literal 2 binary64) (+.f64 re im))
(+ (* 2 im) (* 2 re))
(*.f64 #s(literal 2 binary64) (+.f64 re im))
(* 2 re)
(*.f64 re #s(literal 2 binary64))
(* re (+ 2 (* 2 (/ im re))))
(fma.f64 #s(literal 2 binary64) (/.f64 im #s(literal 1 binary64)) (*.f64 re #s(literal 2 binary64)))
(* re (+ 2 (* 2 (/ im re))))
(fma.f64 #s(literal 2 binary64) (/.f64 im #s(literal 1 binary64)) (*.f64 re #s(literal 2 binary64)))
(* re (+ 2 (* 2 (/ im re))))
(fma.f64 #s(literal 2 binary64) (/.f64 im #s(literal 1 binary64)) (*.f64 re #s(literal 2 binary64)))
(* 2 re)
(*.f64 re #s(literal 2 binary64))
(* -1 (* re (- (* -2 (/ im re)) 2)))
(fma.f64 #s(literal 2 binary64) (/.f64 im #s(literal 1 binary64)) (*.f64 re #s(literal 2 binary64)))
(* -1 (* re (- (* -2 (/ im re)) 2)))
(fma.f64 #s(literal 2 binary64) (/.f64 im #s(literal 1 binary64)) (*.f64 re #s(literal 2 binary64)))
(* -1 (* re (- (* -2 (/ im re)) 2)))
(fma.f64 #s(literal 2 binary64) (/.f64 im #s(literal 1 binary64)) (*.f64 re #s(literal 2 binary64)))
(sqrt re)
(sqrt.f64 re)
(sqrt re)
(sqrt.f64 re)
(sqrt re)
(sqrt.f64 re)
(sqrt re)
(sqrt.f64 re)
(sqrt re)
(sqrt.f64 re)
(sqrt re)
(sqrt.f64 re)
(sqrt re)
(sqrt.f64 re)
(sqrt re)
(sqrt.f64 re)
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(sqrt.f64 re)
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(sqrt.f64 re)
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(sqrt.f64 re)
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(sqrt.f64 re)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal -1/2 binary64)))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal -1/2 binary64)))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal -1/2 binary64)))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal -1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (*.f64 im (sqrt.f64 #s(literal -1 binary64)))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (*.f64 im (sqrt.f64 #s(literal -1 binary64)))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (*.f64 im (sqrt.f64 #s(literal -1 binary64)))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (*.f64 im (sqrt.f64 #s(literal -1 binary64)))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im (sqrt.f64 #s(literal -1 binary64))))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 im)) (/ re (sqrt 2)))))
(*.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 re (sqrt.f64 #s(literal 2 binary64))))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2))))) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))))))
(fma.f64 re (fma.f64 (/.f64 (*.f64 re (-.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) (sqrt.f64 #s(literal 2 binary64))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 #s(literal 2 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 (* (pow im 2) (pow (sqrt 2) 4))) (/ 1 (* (pow im 2) (pow (sqrt 2) 2))))) (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (/ (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2)))) (sqrt 2)))))))))
(fma.f64 re (fma.f64 re (*.f64 (*.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 im im) (pow.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (/.f64 re (sqrt.f64 #s(literal 2 binary64))) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 1/2 binary64) im)) (sqrt.f64 #s(literal 2 binary64))))) (*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 #s(literal 2 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64))))
(* 1/2 (* (sqrt (/ 1 im)) re))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 re #s(literal 1/2 binary64)))
(* re (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re)))))
(*.f64 #s(literal 1/2 binary64) (fma.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 im)))
(* re (+ (* 1/4 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re))))))
(fma.f64 re (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) im) (*.f64 re re)) (*.f64 (sqrt.f64 im) #s(literal 1/4 binary64)))) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)))
(* re (+ (* -1/4 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) (pow re 3)))) (+ (* 1/4 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re)))))))
(fma.f64 re (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (sqrt.f64 (*.f64 im (*.f64 im im))) (-.f64 (*.f64 #s(literal 2 binary64) im) im)) (*.f64 re (*.f64 re re))) (*.f64 (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) im) (*.f64 re re)) (*.f64 (sqrt.f64 im) #s(literal 1/4 binary64)))) (*.f64 #s(literal 1/2 binary64) (fma.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 im))))
(* -1/2 (* (sqrt (/ 1 im)) re))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 re #s(literal -1/2 binary64)))
(* -1 (* re (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re))))))
(*.f64 #s(literal -1/2 binary64) (fma.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 im)))
(* -1 (* re (+ (* -1 (/ (+ (* -1/2 (sqrt im)) (* -1/4 (* (sqrt im) (/ (- (* 2 im) im) re)))) re)) (* 1/2 (sqrt (/ 1 im))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (sqrt.f64 im) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) im) re)) (*.f64 (sqrt.f64 im) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) re)))))
(* -1 (* re (+ (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) re))) (* 1/4 (* (sqrt im) (- (* 2 im) im)))) re)) (* -1/2 (sqrt im))) re)) (* 1/2 (sqrt (/ 1 im))))))
(*.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (/.f64 (-.f64 (*.f64 (sqrt.f64 im) #s(literal -1/2 binary64)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (sqrt.f64 (*.f64 im (*.f64 im im))) (-.f64 (*.f64 #s(literal 2 binary64) im) im)) re) (*.f64 (sqrt.f64 im) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) im) #s(literal 1/4 binary64)))) re)) re)) (-.f64 #s(literal 0 binary64) re))
(* 1/2 (* (sqrt (/ 1 im)) re))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 re #s(literal 1/2 binary64)))
(/ (+ (* 1/2 (sqrt (pow im 3))) (* 1/2 (* (sqrt im) re))) im)
(/.f64 (*.f64 #s(literal 1/2 binary64) (fma.f64 re (sqrt.f64 im) (sqrt.f64 (*.f64 im (*.f64 im im))))) im)
(/ (+ (* 1/2 (* (sqrt im) re)) (* (pow im 2) (+ (* 1/2 (sqrt (/ 1 im))) (* 1/2 (* (sqrt im) (/ 1 re)))))) im)
(/.f64 (fma.f64 (*.f64 (*.f64 im im) #s(literal 1/2 binary64)) (+.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (sqrt.f64 im) re)) (*.f64 re (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)))) im)
(/ (+ (* 1/2 (* (sqrt im) re)) (* (pow im 2) (+ (* 1/2 (sqrt (/ 1 im))) (* im (+ (* -1/4 (* (sqrt (/ 1 im)) (/ 1 re))) (* 1/2 (* (sqrt (/ 1 im)) (/ 1 re)))))))) im)
(/.f64 (fma.f64 (*.f64 im im) (fma.f64 im (*.f64 (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) re) #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (*.f64 re (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)))) im)
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)))
(* im (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2))))))
(*.f64 (*.f64 im #s(literal 1/2 binary64)) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (/.f64 re (sqrt.f64 #s(literal 2 binary64))))))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))))))
(*.f64 im (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) (sqrt.f64 #s(literal 2 binary64)))) (*.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (/.f64 re (sqrt.f64 #s(literal 2 binary64))))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2))))))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (/.f64 re (sqrt.f64 #s(literal 2 binary64))))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) (sqrt.f64 #s(literal 2 binary64)))) (*.f64 #s(literal -1/8 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) (sqrt.f64 #s(literal 2 binary64))))))))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(*.f64 (*.f64 (sqrt.f64 im) #s(literal -1/2 binary64)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2)))))))
(*.f64 #s(literal -1/2 binary64) (*.f64 im (fma.f64 re (*.f64 (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64)))))))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2))))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 #s(literal 1/2 binary64) (fma.f64 re (*.f64 (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re re) (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64)))))))))
(* -1 (* im (+ (* -1 (/ (+ (* -1/4 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (* 1/4 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (pow (sqrt -2) 3))))) (pow im 3))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2))))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 #s(literal 1/2 binary64) (fma.f64 re (*.f64 (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 #s(literal -1 binary64))) (*.f64 re re)) (sqrt.f64 #s(literal -2 binary64))) (*.f64 (*.f64 (*.f64 re re) (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64)))) (*.f64 (sqrt.f64 im) #s(literal -1/4 binary64)))) (-.f64 #s(literal 0 binary64) (*.f64 im (*.f64 im im)))))))
(* (sqrt im) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(+ (* (sqrt im) (sqrt 2)) (* (sqrt (/ 1 im)) (/ re (sqrt 2))))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 re (sqrt.f64 #s(literal 2 binary64)))))
(+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2))))) (sqrt 2)))) (* (sqrt (/ 1 im)) (/ 1 (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 re (*.f64 (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 1/2 binary64) im)) (sqrt.f64 #s(literal 2 binary64))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(+ (* re (+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (/ (* re (- (/ 1 (* (pow im 2) (pow (sqrt 2) 4))) (/ 1 (* (pow im 2) (pow (sqrt 2) 2))))) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (/ (- (/ 1 im) (/ 1 (* im (pow (sqrt 2) 2)))) (sqrt 2)))))) (* (sqrt (/ 1 im)) (/ 1 (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 re (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (fma.f64 (-.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 im im) (pow.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (/.f64 re (sqrt.f64 #s(literal 2 binary64))) (/.f64 (-.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 1/2 binary64) im)) (sqrt.f64 #s(literal 2 binary64))))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* (sqrt (/ 1 im)) re)
(*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))
(* re (+ (sqrt (/ 1 im)) (* (sqrt im) (/ 1 re))))
(fma.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 im))
(* re (+ (sqrt (/ 1 im)) (+ (* 1/2 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (* (sqrt im) (/ 1 re)))))
(fma.f64 re (fma.f64 (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) im) (*.f64 re re)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (sqrt.f64 im))
(* re (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) (pow re 3)))) (+ (* 1/2 (* (sqrt im) (/ (- (* 2 im) im) (pow re 2)))) (* (sqrt im) (/ 1 re))))))
(fma.f64 re (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (sqrt.f64 (*.f64 im (*.f64 im im))) (-.f64 (*.f64 #s(literal 2 binary64) im) im)) (*.f64 re (*.f64 re re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (fma.f64 re (/.f64 (*.f64 (sqrt.f64 im) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) im) #s(literal 1/2 binary64))) (*.f64 re re)) (sqrt.f64 im)))
(* -1 (* (sqrt (/ 1 im)) re))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (sqrt (/ 1 im)) (* (sqrt im) (/ 1 re)))))
(-.f64 #s(literal 0 binary64) (fma.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 im)))
(* -1 (* re (+ (sqrt (/ 1 im)) (* -1 (/ (+ (* -1 (sqrt im)) (* -1/2 (* (sqrt im) (/ (- (* 2 im) im) re)))) re)))))
(-.f64 #s(literal 0 binary64) (*.f64 re (-.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (-.f64 (*.f64 (*.f64 (sqrt.f64 im) #s(literal -1/2 binary64)) (/.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) im) re)) (sqrt.f64 im)) re))))
(* -1 (* re (+ (sqrt (/ 1 im)) (* -1 (/ (+ (* -1 (sqrt im)) (* -1 (/ (+ (* -1/2 (* (sqrt (pow im 3)) (/ (- (* 2 im) im) re))) (* 1/2 (* (sqrt im) (- (* 2 im) im)))) re))) re)))))
(*.f64 (+.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (+.f64 (sqrt.f64 im) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (sqrt.f64 (*.f64 im (*.f64 im im))) (-.f64 (*.f64 #s(literal 2 binary64) im) im)) re) (*.f64 (sqrt.f64 im) (*.f64 (-.f64 (*.f64 #s(literal 2 binary64) im) im) #s(literal 1/2 binary64)))) re)) re)) (-.f64 #s(literal 0 binary64) re))
(* (sqrt (/ 1 im)) re)
(*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))
(/ (+ (sqrt (pow im 3)) (* (sqrt im) re)) im)
(/.f64 (fma.f64 re (sqrt.f64 im) (sqrt.f64 (*.f64 im (*.f64 im im)))) im)
(/ (+ (* (sqrt im) re) (* (pow im 2) (+ (sqrt (/ 1 im)) (* (sqrt im) (/ 1 re))))) im)
(/.f64 (fma.f64 re (sqrt.f64 im) (*.f64 (*.f64 im im) (+.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (/.f64 (sqrt.f64 im) re)))) im)
(/ (+ (* (sqrt im) re) (* (pow im 2) (+ (sqrt (/ 1 im)) (* im (+ (* -1/2 (* (sqrt (/ 1 im)) (/ 1 re))) (* (sqrt (/ 1 im)) (/ 1 re))))))) im)
(/.f64 (fma.f64 re (sqrt.f64 im) (*.f64 (*.f64 im im) (fma.f64 im (*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))) im)
(* (sqrt im) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(* im (+ (* (sqrt (/ 1 im)) (sqrt 2)) (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))))
(*.f64 im (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (/.f64 re (sqrt.f64 #s(literal 2 binary64))))))
(* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* (sqrt (/ 1 im)) (sqrt 2)) (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2))))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) (sqrt.f64 #s(literal 2 binary64)))) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (/.f64 re (sqrt.f64 #s(literal 2 binary64)))))))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (sqrt 2)))) (+ (* (sqrt (/ 1 im)) (sqrt 2)) (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))))))
(*.f64 im (fma.f64 #s(literal -1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) (sqrt.f64 #s(literal 2 binary64)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) (sqrt.f64 #s(literal 2 binary64)))) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (/.f64 re (sqrt.f64 #s(literal 2 binary64))))))))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal -2 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64)))))
(* -1 (* im (+ (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2))))))
(*.f64 (fma.f64 re (*.f64 (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (+ (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2)))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re re) (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))) (fma.f64 re (*.f64 (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))))))
(* -1 (* im (+ (* -1 (/ (+ (* -1/2 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (sqrt -2)))) (* 1/2 (* (sqrt im) (/ (* (pow re 2) (sqrt -1)) (pow (sqrt -2) 3))))) (pow im 3))) (+ (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (sqrt -1)) (sqrt -2)))))))
(*.f64 (-.f64 (fma.f64 re (*.f64 (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64))))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 #s(literal -1 binary64))) (*.f64 re re)) (sqrt.f64 #s(literal -2 binary64))) (*.f64 (*.f64 (*.f64 re re) (/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -2 binary64)))) (*.f64 (sqrt.f64 im) #s(literal -1/4 binary64)))) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) im))
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(+ (* 2 im) (* 2 re))
(*.f64 #s(literal 2 binary64) (+.f64 re im))
(+ (* 2 im) (* re (+ 2 (/ re im))))
(fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))
(+ (* 2 im) (* re (+ 2 (/ re im))))
(fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(* (pow re 2) (+ (/ 1 im) (* 2 (/ 1 re))))
(*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))
(* (pow re 2) (+ (* 2 (/ im (pow re 2))) (+ (/ 1 im) (* 2 (/ 1 re)))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal 2 binary64) (/.f64 im (*.f64 re re)) (/.f64 #s(literal 1 binary64) im)) (*.f64 re #s(literal 2 binary64)))
(* (pow re 2) (+ (* 2 (/ im (pow re 2))) (+ (/ 1 im) (* 2 (/ 1 re)))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal 2 binary64) (/.f64 im (*.f64 re re)) (/.f64 #s(literal 1 binary64) im)) (*.f64 re #s(literal 2 binary64)))
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(* (pow re 2) (+ (/ 1 im) (* 2 (/ 1 re))))
(*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)))
(* (pow re 2) (+ (* -1 (/ (- (* -2 (/ im re)) 2) re)) (/ 1 im)))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal 2 binary64)) re)))
(* (pow re 2) (+ (* -1 (/ (- (* -2 (/ im re)) 2) re)) (/ 1 im)))
(*.f64 (*.f64 re re) (+.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal 2 binary64)) re)))
(/ (pow re 2) im)
(/.f64 (*.f64 re re) im)
(/ (+ (* 2 (* im re)) (pow re 2)) im)
(/.f64 (*.f64 re (fma.f64 #s(literal 2 binary64) im re)) im)
(/ (+ (* im (+ (* 2 im) (* 2 re))) (pow re 2)) im)
(/.f64 (fma.f64 #s(literal 2 binary64) (*.f64 (+.f64 re im) im) (*.f64 re re)) im)
(/ (+ (* im (+ (* 2 im) (* 2 re))) (pow re 2)) im)
(/.f64 (fma.f64 #s(literal 2 binary64) (*.f64 (+.f64 re im) im) (*.f64 re re)) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* im (+ 2 (* 2 (/ re im))))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) #s(literal 2 binary64)))
(* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 2 binary64))))
(* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 2 binary64))))
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* -1 (* im (- (* -2 (/ re im)) 2)))
(*.f64 im (fma.f64 re (/.f64 #s(literal 2 binary64) im) #s(literal 2 binary64)))
(* -1 (* im (- (* -1 (/ (+ (* 2 re) (/ (pow re 2) im)) im)) 2)))
(*.f64 (-.f64 #s(literal -2 binary64) (/.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) im)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (- (* -1 (/ (+ (* 2 re) (/ (pow re 2) im)) im)) 2)))
(*.f64 (-.f64 #s(literal -2 binary64) (/.f64 (*.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im))) im)) (-.f64 #s(literal 0 binary64) im))
2
#s(literal 2 binary64)
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(/ re im)
(/.f64 re im)
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(/ re im)
(/.f64 re im)
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(* re (+ (/ 1 im) (* 2 (/ 1 re))))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(/ re im)
(/.f64 re im)
(/ (+ re (* 2 im)) im)
(/.f64 (fma.f64 #s(literal 2 binary64) im re) im)
(/ (+ re (* 2 im)) im)
(/.f64 (fma.f64 #s(literal 2 binary64) im re) im)
(/ (+ re (* 2 im)) im)
(/.f64 (fma.f64 #s(literal 2 binary64) im re) im)
2
#s(literal 2 binary64)
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
2
#s(literal 2 binary64)
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(+ 2 (/ re im))
(+.f64 #s(literal 2 binary64) (/.f64 re im))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)

eval125.0ms (1.3%)

Memory
-26.7MiB live, 304.7MiB allocated
Compiler

Compiled 22 960 to 3 290 computations (85.7% saved)

prune117.0ms (1.2%)

Memory
12.0MiB live, 281.7MiB allocated
Pruning

16 alts after pruning (12 fresh and 4 done)

PrunedKeptTotal
New1 01861 024
Fresh167
Picked145
Done000
Total1 020161 036
Accuracy
99.4%
Counts
1 036 → 16
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶54.9%
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
▶51.8%
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
14.7%
(*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
14.7%
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)))))
21.5%
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (neg.f64 (/.f64 im re)))))
✓52.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))))
▶29.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
✓13.3%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))))
17.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re)))))
51.7%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
39.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) re))))
41.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))) re))))
▶41.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
✓54.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
✓29.4%
(sqrt.f64 re)
▶5.4%
#s(literal 0 binary64)
Compiler

Compiled 347 to 252 computations (27.4% saved)

simplify7.0ms (0.1%)

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

Found 16 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)
✓cost-diff0
(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
✓cost-diff0
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
✓cost-diff0
(/.f64 im re)
✓cost-diff0
(fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))
✓cost-diff0
(sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
✓cost-diff0
(sqrt.f64 #s(literal 2 binary64))
✓cost-diff0
(*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))
✓cost-diff0
(sqrt.f64 im)
✓cost-diff0
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
✓cost-diff0
(sqrt.f64 (+.f64 im re))
✓cost-diff0
(sqrt.f64 #s(literal 2 binary64))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))
✓cost-diff0
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
Rules
76×*-lowering-*.f32
76×*-lowering-*.f64
32×*-commutative
20×+-lowering-+.f64
20×+-lowering-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
028158
151158
267158
371158
071129
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(* (* 1/2 (sqrt 2)) (sqrt (+ im re)))
(* 1/2 (sqrt 2))
1/2
(sqrt 2)
2
(sqrt (+ im re))
(+ im re)
im
re
0
(* (sqrt im) (* (sqrt 2) 1/2))
(sqrt im)
im
(* (sqrt 2) 1/2)
(sqrt 2)
2
1/2
(* 1/2 (sqrt (+ (* im (/ im re)) (* re 4))))
1/2
(sqrt (+ (* im (/ im re)) (* re 4)))
(+ (* im (/ im re)) (* re 4))
im
(/ im re)
re
(* re 4)
4
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) re))))
1/2
(sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) re)))
(* 2 (+ (sqrt (+ (* im im) (* re re))) re))
2
(+ (sqrt (+ (* im im) (* re re))) re)
(sqrt (+ (* im im) (* re re)))
(+ (* im im) (* re re))
im
(* re re)
re
Outputs
(* (* 1/2 (sqrt 2)) (sqrt (+ im re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
(* 1/2 (sqrt 2))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))
1/2
#s(literal 1/2 binary64)
(sqrt 2)
(sqrt.f64 #s(literal 2 binary64))
2
#s(literal 2 binary64)
(sqrt (+ im re))
(sqrt.f64 (+.f64 im re))
(+ im re)
(+.f64 im re)
im
re
0
#s(literal 0 binary64)
(* (sqrt im) (* (sqrt 2) 1/2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
(sqrt im)
(sqrt.f64 im)
im
(* (sqrt 2) 1/2)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))
(sqrt 2)
(sqrt.f64 #s(literal 2 binary64))
2
#s(literal 2 binary64)
1/2
#s(literal 1/2 binary64)
(* 1/2 (sqrt (+ (* im (/ im re)) (* re 4))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
1/2
#s(literal 1/2 binary64)
(sqrt (+ (* im (/ im re)) (* re 4)))
(sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))
(+ (* im (/ im re)) (* re 4))
(fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))
im
(/ im re)
(/.f64 im re)
re
(* re 4)
(*.f64 re #s(literal 4 binary64))
4
#s(literal 4 binary64)
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
1/2
#s(literal 1/2 binary64)
(sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) re)))
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(* 2 (+ (sqrt (+ (* im im) (* re re))) re))
(*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
2
#s(literal 2 binary64)
(+ (sqrt (+ (* im im) (* re re))) re)
(+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(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

localize102.0ms (1.1%)

Memory
8.6MiB live, 166.6MiB allocated
Localize:

Found 16 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(fma.f64 im im (*.f64 re re))
✓accuracy100.0%
(+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)
✓accuracy100.0%
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
✓accuracy71.8%
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓accuracy100.0%
(*.f64 re #s(literal 4 binary64))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
✓accuracy99.9%
(fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))
✓accuracy93.0%
(sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))
✓accuracy100.0%
(*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))
✓accuracy100.0%
(sqrt.f64 im)
✓accuracy100.0%
(sqrt.f64 #s(literal 2 binary64))
✓accuracy99.6%
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))
✓accuracy100.0%
(sqrt.f64 #s(literal 2 binary64))
✓accuracy100.0%
(sqrt.f64 (+.f64 im re))
✓accuracy99.6%
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
Samples
42.0ms113×0invalid
29.0ms143×0valid
Compiler

Compiled 151 to 30 computations (80.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 55.0ms
ival-mult: 30.0ms (54.6% of total)
ival-sqrt: 17.0ms (31% of total)
ival-add: 5.0ms (9.1% of total)
ival-div: 2.0ms (3.6% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series32.0ms (0.3%)

Memory
0.1MiB live, 69.3MiB allocated
Counts
18 → 324
Calls
Call 1
Inputs
#<alt (* (* 1/2 (sqrt 2)) (sqrt (+ im re)))>
#<alt (* 1/2 (sqrt 2))>
#<alt (sqrt 2)>
#<alt (sqrt (+ im re))>
#<alt (* (sqrt im) (* (sqrt 2) 1/2))>
#<alt (sqrt im)>
#<alt (* (sqrt 2) 1/2)>
#<alt (* 1/2 (sqrt (+ (* im (/ im re)) (* re 4))))>
#<alt (sqrt (+ (* im (/ im re)) (* re 4)))>
#<alt (+ (* im (/ im re)) (* re 4))>
#<alt (/ im re)>
#<alt (* 1/2 (sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) re))))>
#<alt (sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) re)))>
#<alt (* 2 (+ (sqrt (+ (* im im) (* re re))) re))>
#<alt (+ (sqrt (+ (* im im) (* re re))) re)>
#<alt (* re 4)>
#<alt (sqrt (+ (* im im) (* re re)))>
#<alt (+ (* im im) (* re re))>
Outputs
#<alt (* 1/2 (* (sqrt re) (sqrt 2)))>
#<alt (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (sqrt 2))))>
#<alt (+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* -1/16 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))))))>
#<alt (+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (sqrt 2))) (* 1/32 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 5))))))))))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))>
#<alt (* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))>
#<alt (* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))>
#<alt (* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (sqrt 2)) (pow (sqrt -1) 4)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))) (* 1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))))))))>
#<alt (* 1/2 (* (sqrt re) (sqrt 2)))>
#<alt (* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))>
#<alt (* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))))))>
#<alt (* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (sqrt 2)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))))>
#<alt (* -1/2 (* (sqrt re) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (* -1 (* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))>
#<alt (* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))))>
#<alt (* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))>
#<alt (sqrt re)>
#<alt (+ (sqrt re) (* 1/2 (* im (sqrt (/ 1 re)))))>
#<alt (+ (sqrt re) (* im (+ (* -1/8 (* im (sqrt (/ 1 (pow re 3))))) (* 1/2 (sqrt (/ 1 re))))))>
#<alt (+ (sqrt re) (* im (+ (* 1/2 (sqrt (/ 1 re))) (* im (+ (* -1/8 (sqrt (/ 1 (pow re 3)))) (* 1/16 (* im (sqrt (/ 1 (pow re 5))))))))))>
#<alt (sqrt im)>
#<alt (* im (+ (sqrt (/ 1 im)) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))>
#<alt (* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)))))>
#<alt (* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))))>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt -1) 4)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))>
#<alt (sqrt im)>
#<alt (+ (sqrt im) (* 1/2 (* (sqrt (/ 1 im)) re)))>
#<alt (+ (sqrt im) (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (sqrt (/ 1 im))))))>
#<alt (+ (sqrt im) (* re (+ (* 1/2 (sqrt (/ 1 im))) (* re (+ (* -1/8 (sqrt (/ 1 (pow im 3)))) (* 1/16 (* (sqrt (/ 1 (pow im 5))) re)))))))>
#<alt (sqrt re)>
#<alt (* re (+ (sqrt (/ 1 re)) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))>
#<alt (* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3))))))))>
#<alt (* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (pow im 3) (sqrt (/ 1 (pow re 7))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))))>
#<alt (* -1 (* (sqrt re) (pow (sqrt -1) 2)))>
#<alt (* -1 (* re (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))>
#<alt (* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))>
#<alt (* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (pow im 3) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (sqrt re)>
#<alt (+ (sqrt re) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))))>
#<alt (+ (sqrt re) (* (pow im 2) (+ (* -1/128 (* (pow im 2) (sqrt (/ 1 (pow re 7))))) (* 1/8 (sqrt (/ 1 (pow re 3)))))))>
#<alt (+ (sqrt re) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/128 (sqrt (/ 1 (pow re 7)))) (* 1/1024 (* (pow im 2) (sqrt (/ 1 (pow re 11))))))))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* im (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))>
#<alt (* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))>
#<alt (* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (+ (* 2 (* (/ 1 (pow im 6)) (sqrt (pow re 11)))) (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))>
#<alt (* -1/2 (* im (sqrt (/ 1 re))))>
#<alt (* -1 (* im (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))>
#<alt (* -1 (* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))>
#<alt (* -1 (* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (+ (* 2 (* (/ 1 (pow im 6)) (sqrt (pow re 11)))) (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (/ (+ (* 1/2 (* im (sqrt re))) (* (/ 1 im) (sqrt (pow re 5)))) re)>
#<alt (/ (+ (* 1/2 (* im (sqrt re))) (* (pow re 3) (+ (* -1 (* (/ 1 (pow im 3)) (sqrt (pow re 3)))) (* (/ 1 im) (sqrt (/ 1 re)))))) re)>
#<alt (/ (+ (* 1/2 (* im (sqrt re))) (* (pow re 3) (+ (* (/ 1 im) (sqrt (/ 1 re))) (* (pow re 3) (+ (* -1 (* (/ 1 (pow im 3)) (sqrt (/ 1 (pow re 3))))) (* 2 (* (/ 1 (pow im 5)) (sqrt re)))))))) re)>
#<alt (sqrt re)>
#<alt (* re (+ (sqrt (/ 1 re)) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5)))))))>
#<alt (* re (+ (sqrt (/ 1 re)) (+ (* -1/128 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))))))>
#<alt (* re (+ (sqrt (/ 1 re)) (+ (* -1/128 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/1024 (* (pow im 6) (sqrt (/ 1 (pow re 13))))) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5)))))))))>
#<alt (* -1/2 (* (sqrt re) (* (sqrt -4) (sqrt -1))))>
#<alt (* -1 (* re (+ (* 1/4 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1)))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/4 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re))) (* 1/16 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1)))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (pow re 3)))) (* 1/32 (* (/ (* (pow im 6) (sqrt -1)) (pow (sqrt -4) 5)) (sqrt (/ 1 re))))) (pow re 3))) (* -1/4 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re)))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1)))))))>
#<alt (* 2 (sqrt re))>
#<alt (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 2 (sqrt re)))>
#<alt (+ (* 2 (sqrt re)) (* (pow im 2) (+ (* -1/64 (* (pow im 2) (sqrt (/ 1 (pow re 7))))) (* 1/4 (sqrt (/ 1 (pow re 3)))))))>
#<alt (+ (* 2 (sqrt re)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/64 (sqrt (/ 1 (pow re 7)))) (* 1/512 (* (pow im 2) (sqrt (/ 1 (pow re 11))))))))))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (+ (sqrt (/ 1 re)) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))>
#<alt (* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))>
#<alt (* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))) (* 4 (* (/ 1 (pow im 6)) (sqrt (pow re 11))))))))>
#<alt (* -1 (* im (sqrt (/ 1 re))))>
#<alt (* -1 (* im (+ (sqrt (/ 1 re)) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))>
#<alt (* -1 (* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))))>
#<alt (* -1 (* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))) (* 4 (* (/ 1 (pow im 6)) (sqrt (pow re 11)))))))))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (/ (+ (* 2 (* (/ 1 im) (sqrt (pow re 5)))) (* im (sqrt re))) re)>
#<alt (/ (+ (* im (sqrt re)) (* (pow re 3) (+ (* -2 (* (/ 1 (pow im 3)) (sqrt (pow re 3)))) (* 2 (* (/ 1 im) (sqrt (/ 1 re))))))) re)>
#<alt (/ (+ (* im (sqrt re)) (* (pow re 3) (+ (* 2 (* (/ 1 im) (sqrt (/ 1 re)))) (* (pow re 3) (+ (* -2 (* (/ 1 (pow im 3)) (sqrt (/ 1 (pow re 3))))) (* 4 (* (/ 1 (pow im 5)) (sqrt re)))))))) re)>
#<alt (* 2 (sqrt re))>
#<alt (* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 2 (sqrt (/ 1 re)))))>
#<alt (* re (+ (* -1/64 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 2 (sqrt (/ 1 re))))))>
#<alt (* re (+ (* -1/64 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/512 (* (pow im 6) (sqrt (/ 1 (pow re 13))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 2 (sqrt (/ 1 re)))))))>
#<alt (* -1 (* (sqrt re) (* (sqrt -4) (sqrt -1))))>
#<alt (* -1 (* re (+ (* 1/2 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/2 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re))) (* 1/8 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1 (/ (+ (* -1/8 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (pow re 3)))) (* 1/16 (* (/ (* (pow im 6) (sqrt -1)) (pow (sqrt -4) 5)) (sqrt (/ 1 re))))) (pow re 3))) (* -1/2 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re)))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1))))))>
#<alt (* 4 re)>
#<alt (+ (* 4 re) (/ (pow im 2) re))>
#<alt (+ (* 4 re) (/ (pow im 2) re))>
#<alt (+ (* 4 re) (/ (pow im 2) re))>
#<alt (/ (pow im 2) re)>
#<alt (* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))>
#<alt (* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))>
#<alt (* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))>
#<alt (/ (pow im 2) re)>
#<alt (* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))>
#<alt (* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))>
#<alt (* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))>
#<alt (/ (pow im 2) re)>
#<alt (/ (+ (* 4 (pow re 2)) (pow im 2)) re)>
#<alt (/ (+ (* 4 (pow re 2)) (pow im 2)) re)>
#<alt (/ (+ (* 4 (pow re 2)) (pow im 2)) re)>
#<alt (* 4 re)>
#<alt (* re (+ 4 (/ (pow im 2) (pow re 2))))>
#<alt (* re (+ 4 (/ (pow im 2) (pow re 2))))>
#<alt (* re (+ 4 (/ (pow im 2) (pow re 2))))>
#<alt (* 4 re)>
#<alt (* -1 (* re (- (* -1 (/ (pow im 2) (pow re 2))) 4)))>
#<alt (* -1 (* re (- (* -1 (/ (pow im 2) (pow re 2))) 4)))>
#<alt (* -1 (* re (- (* -1 (/ (pow im 2) (pow re 2))) 4)))>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))>
#<alt (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))))>
#<alt (+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* -1/4 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/8 (sqrt (/ 1 (pow re 3)))))))>
#<alt (+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/4 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/4 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))>
#<alt (* -1/2 (* (sqrt im) (* (sqrt -1) (sqrt 2))))>
#<alt (* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))>
#<alt (* -1 (* im (+ (* -1 (/ (+ (* 1/16 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))))>
#<alt (* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))>
#<alt (* re (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))>
#<alt (* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))>
#<alt (* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/64 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))))>
#<alt (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))>
#<alt (+ (* 1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))>
#<alt (+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))>
#<alt (+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/1024 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))>
#<alt (* (sqrt re) (pow (sqrt 2) 2))>
#<alt (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* (sqrt re) (pow (sqrt 2) 2)))>
#<alt (+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/4 (sqrt (/ 1 (pow re 3)))))))>
#<alt (+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/2 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))>
#<alt (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* -1 (* (sqrt im) (* (sqrt -1) (sqrt 2))))>
#<alt (* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))>
#<alt (* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* -1 (* im (+ (* -1 (/ (+ (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/4 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (+ (* 1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))>
#<alt (+ (* re (+ (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (* (sqrt im) (sqrt 2)))>
#<alt (+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))) (* (sqrt im) (sqrt 2)))>
#<alt (* (sqrt re) (pow (sqrt 2) 2))>
#<alt (* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))>
#<alt (* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))>
#<alt (* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/32 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))>
#<alt (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))>
#<alt (+ (* 1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))>
#<alt (+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))>
#<alt (+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/512 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))>
#<alt (* 4 re)>
#<alt (+ (* 4 re) (/ (pow im 2) re))>
#<alt (+ (* 4 re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re))))>
#<alt (+ (* 4 re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re))))>
#<alt (* 2 im)>
#<alt (* im (+ 2 (* 2 (/ re im))))>
#<alt (* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 2 (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2))))))>
#<alt (* -2 im)>
#<alt (* -1 (* im (+ 2 (* -2 (/ re im)))))>
#<alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (pow re 2) im)) (* 2 re)) im)))))>
#<alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im)) (* 2 re)) im)))))>
#<alt (* 2 im)>
#<alt (+ (* 2 im) (* 2 re))>
#<alt (+ (* 2 im) (* re (+ 2 (/ re im))))>
#<alt (+ (* 2 im) (* re (+ 2 (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))))))>
#<alt (* 4 re)>
#<alt (* re (+ 4 (/ (pow im 2) (pow re 2))))>
#<alt (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/8 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re))>
#<alt (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re))>
#<alt (* -1 (/ (+ (* -1 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2)))) re))>
#<alt (* 2 re)>
#<alt (+ (* 1/2 (/ (pow im 2) re)) (* 2 re))>
#<alt (+ (* 2 re) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ (* 2 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 (/ re im)))>
#<alt (* im (+ 1 (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im)))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* -1 (/ re im)))))>
#<alt (* -1 (* im (+ 1 (* -1 (/ (+ re (* -1/2 (/ (pow re 2) im))) im)))))>
#<alt (* -1 (* im (+ 1 (* -1 (/ (+ re (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im))) im)))))>
#<alt im>
#<alt (+ im re)>
#<alt (+ im (* re (+ 1 (* 1/2 (/ re im)))))>
#<alt (+ im (* re (+ 1 (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))>
#<alt (* 2 re)>
#<alt (* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 2 (+ (* -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/2 (/ (pow im 2) re))>
#<alt (* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re))>
#<alt (* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re))>
#<alt (* -1 (/ (+ (* -1/2 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2))))) re))>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<alt (* 4 re)>
#<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))))>
Calls

81 calls:

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

rewrite379.0ms (3.9%)

Memory
6.0MiB live, 653.4MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
7 848×accelerator-lowering-fma.f32
7 848×accelerator-lowering-fma.f64
5 802×*-lowering-*.f32
5 802×*-lowering-*.f64
3 792×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
027134
1112132
2764132
08348102
Stop Event
1×iter limit
1×node limit
Counts
18 → 495
Calls
Call 1
Inputs
(* (* 1/2 (sqrt 2)) (sqrt (+ im re)))
(* 1/2 (sqrt 2))
(sqrt 2)
(sqrt (+ im re))
(* (sqrt im) (* (sqrt 2) 1/2))
(sqrt im)
(* (sqrt 2) 1/2)
(* 1/2 (sqrt (+ (* im (/ im re)) (* re 4))))
(sqrt (+ (* im (/ im re)) (* re 4)))
(+ (* im (/ im re)) (* re 4))
(/ im re)
(* 1/2 (sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) re))))
(sqrt (* 2 (+ (sqrt (+ (* im im) (* re re))) re)))
(* 2 (+ (sqrt (+ (* im im) (* re re))) re))
(+ (sqrt (+ (* im im) (* re re))) re)
(* re 4)
(sqrt (+ (* im im) (* re re)))
(+ (* im im) (* re re))
Outputs
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 im im (*.f64 re (-.f64 re im)))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (-.f64 im re)))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re)))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 (fma.f64 im im (*.f64 re (-.f64 re im)))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 (-.f64 im re)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 (+.f64 im re)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (+.f64 im re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
(*.f64 (sqrt.f64 (+.f64 im re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (+.f64 im re)))))
(*.f64 (pow.f64 (+.f64 im re) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (+.f64 im re) #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))))
(*.f64 (*.f64 (sqrt.f64 (+.f64 im re)) #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (+.f64 im re))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (pow.f64 (+.f64 im re) #s(literal 1/4 binary64))) (pow.f64 (+.f64 im re) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (*.f64 (sqrt.f64 (+.f64 im re)) #s(literal 1/2 binary64)) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64))) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))
(*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64))) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(sqrt.f64 #s(literal 2 binary64))
(pow.f64 #s(literal 2 binary64) #s(literal 1/2 binary64))
(pow.f64 #s(literal 4 binary64) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (+.f64 im re)) #s(literal 1/2 binary64)))
(hypot.f64 (sqrt.f64 im) (pow.f64 re #s(literal 1/2 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1/2 binary64)) (sqrt.f64 im))
(sqrt.f64 (+.f64 im re))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 im im (*.f64 re (-.f64 re im)))) (sqrt.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (-.f64 im re)) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (sqrt.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re)))) (sqrt.f64 (fma.f64 im im (*.f64 re (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (sqrt.f64 (-.f64 im re)))
(/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re))) (sqrt.f64 (+.f64 (-.f64 #s(literal 0 binary64) im) re)))
(/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im im (*.f64 re (-.f64 re im))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))))) (neg.f64 (sqrt.f64 (fma.f64 im im (*.f64 re (-.f64 re im))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (sqrt.f64 (-.f64 im re))))
(pow.f64 (+.f64 im re) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (+.f64 im re) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (+.f64 im re) (+.f64 im re)) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (+.f64 im re))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re (-.f64 re im))))))
(*.f64 (sqrt.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re (-.f64 re im))))))
(*.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re))))
(*.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 im re))))
(*.f64 (pow.f64 (+.f64 im re) #s(literal 1/4 binary64)) (pow.f64 (+.f64 im re) #s(literal 1/4 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 im))
(*.f64 (sqrt.f64 im) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))))
(*.f64 (pow.f64 im #s(literal 1/4 binary64)) (*.f64 (pow.f64 im #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))))
(*.f64 (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (pow.f64 im #s(literal 1/4 binary64))) (pow.f64 im #s(literal 1/4 binary64)))
(*.f64 (*.f64 (*.f64 (sqrt.f64 im) #s(literal 1/2 binary64)) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64))) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 1/2 binary64)))
(sqrt.f64 im)
(pow.f64 im #s(literal 1/2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 im #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 1/2 binary64))
(*.f64 (pow.f64 im #s(literal 1/4 binary64)) (pow.f64 im #s(literal 1/4 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))
(*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64))) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))))) (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))))) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
(*.f64 (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64))) (pow.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))) #s(literal 1/2 binary64)))
(sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))) (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))))))
(/.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))))
(/.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 re (*.f64 re #s(literal 16 binary64)) (*.f64 (/.f64 (*.f64 im im) re) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))))
(/.f64 (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)))) (sqrt.f64 (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))))) (neg.f64 (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))))) (neg.f64 (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(pow.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))))
(*.f64 (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(*.f64 (sqrt.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(*.f64 (pow.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64)))
(+.f64 (/.f64 (*.f64 im im) re) (*.f64 re #s(literal 4 binary64)))
(+.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))
(+.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re re))) (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(-.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))) (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))
(fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))
(fma.f64 re #s(literal 4 binary64) (/.f64 (*.f64 im im) re))
(fma.f64 (/.f64 im re) im (*.f64 re #s(literal 4 binary64)))
(fma.f64 (/.f64 im re) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) im)) (*.f64 re #s(literal 4 binary64)))
(fma.f64 #s(literal 4 binary64) re (/.f64 (*.f64 im im) re))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 #s(literal -1 binary64) re) im) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))) (neg.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) re) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im (/.f64 #s(literal 1 binary64) im)) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal -1 binary64) re) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (/.f64 im (-.f64 #s(literal 0 binary64) re)) (-.f64 #s(literal 0 binary64) im) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (*.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 im (-.f64 #s(literal 0 binary64) re)) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (/.f64 im re) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 im re) (*.f64 re #s(literal 4 binary64)))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) (neg.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (fma.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) (*.f64 #s(literal -64 binary64) (*.f64 re (*.f64 re re))))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))) (neg.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))) (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))))
(neg.f64 (/.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))) (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(/.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))
(/.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))) (fma.f64 re (*.f64 re #s(literal 16 binary64)) (*.f64 (/.f64 (*.f64 im im) re) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (*.f64 re #s(literal 16 binary64)) (*.f64 (/.f64 (*.f64 im im) re) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))) (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)) (-.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)))))
(/.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 re (*.f64 re #s(literal 16 binary64)) (*.f64 (/.f64 (*.f64 im im) re) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(/.f64 (+.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 9 binary64)) (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re))) #s(literal 262144 binary64))) (*.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 64 binary64)) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))))))
(/.f64 (+.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 9 binary64)) (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re))) #s(literal 262144 binary64))) (*.f64 (fma.f64 re (*.f64 re #s(literal 16 binary64)) (*.f64 (/.f64 (*.f64 im im) re) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 64 binary64)) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))))))
(/.f64 (-.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re))) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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))))) #s(literal 4096 binary64))) (*.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))) (fma.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) (*.f64 #s(literal -64 binary64) (*.f64 re (*.f64 re re))))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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))))) #s(literal 4096 binary64))) (*.f64 (fma.f64 re (*.f64 re #s(literal 16 binary64)) (*.f64 (/.f64 (*.f64 im im) re) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))) (fma.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) (*.f64 #s(literal -64 binary64) (*.f64 re (*.f64 re re))))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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))))) #s(literal 4096 binary64))) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 re (*.f64 re #s(literal 16 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)))))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 256 binary64))) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 re (*.f64 re #s(literal 16 binary64))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re (*.f64 re #s(literal 16 binary64))))) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(/.f64 (*.f64 (+.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 9 binary64)) (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re))) #s(literal 262144 binary64))) #s(literal 1 binary64)) (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 64 binary64)) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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))))) #s(literal 4096 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) (*.f64 #s(literal -64 binary64) (*.f64 re (*.f64 re re)))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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))))) #s(literal 4096 binary64))) #s(literal 1 binary64)) (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 re (*.f64 re #s(literal 16 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re))))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 256 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 re (*.f64 re #s(literal 16 binary64)))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(/.f64 (neg.f64 (-.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)))) (neg.f64 (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re re))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re re))) (fma.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))) (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))) (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re re))) (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re re))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re re)))) (*.f64 (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))) (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))) (+.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (*.f64 re re))) (/.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))) #s(literal 1 binary64)) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))
(/.f64 (*.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))) #s(literal 1 binary64)) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))
(/.f64 (*.f64 (+.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 9 binary64)) (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re))) #s(literal 262144 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 64 binary64)) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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))))) #s(literal 4096 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))) (fma.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) (*.f64 #s(literal -64 binary64) (*.f64 re (*.f64 re re)))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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))))) #s(literal 4096 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))) (+.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (fma.f64 re (*.f64 re #s(literal 16 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 256 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 re (*.f64 re #s(literal 16 binary64)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))) #s(literal -1 binary64))
(*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(*.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))))
(*.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 16 binary64)) (*.f64 (/.f64 (*.f64 im im) re) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))))
(*.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))) (*.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))))
(*.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))
(*.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64))))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))) (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal -4 binary64)))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))))
(*.f64 (-.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))
(*.f64 (/.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64)))) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))
(*.f64 (/.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))) (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))) (*.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (*.f64 (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))))))) (+.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))) (-.f64 (*.f64 (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 re (*.f64 (*.f64 re re) #s(literal 64 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 re (*.f64 re re)))) (-.f64 (/.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re #s(literal 16 binary64))) (*.f64 (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal -4 binary64)) (-.f64 (*.f64 re #s(literal 4 binary64)) (/.f64 (*.f64 im im) re)))))
(*.f64 (/.f64 (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re re) #s(literal -16 binary64))) (fma.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) (*.f64 #s(literal -64 binary64) (*.f64 re (*.f64 re re))))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re re)) (*.f64 (*.f64 re #s(literal 4 binary64)) (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64))))))
(exp.f64 (*.f64 (log.f64 (/.f64 re im)) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 im (-.f64 #s(literal 0 binary64) re)))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) re)) (/.f64 im (-.f64 #s(literal 0 binary64) re)))
(neg.f64 (/.f64 im (-.f64 #s(literal 0 binary64) re)))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (-.f64 #s(literal 0 binary64) re))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 re im)))
(/.f64 im re)
(/.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) re))
(/.f64 #s(literal 1 binary64) (/.f64 re im))
(/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) im))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 re im)))
(/.f64 (*.f64 im #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) re))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (-.f64 #s(literal 0 binary64) re))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) re))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) re)
(pow.f64 (/.f64 re im) #s(literal -1 binary64))
(*.f64 im (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 im re) #s(literal 1 binary64))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal -1 binary64) re))
(*.f64 #s(literal 1 binary64) (/.f64 im re))
(*.f64 (/.f64 #s(literal 1 binary64) re) im)
(*.f64 (/.f64 #s(literal 1 binary64) re) (pow.f64 (/.f64 #s(literal 1 binary64) im) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 im (-.f64 #s(literal 0 binary64) re)))
(*.f64 (/.f64 #s(literal -1 binary64) re) (-.f64 #s(literal 0 binary64) im))
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal -1 binary64) re))
(*.f64 (pow.f64 (/.f64 re im) #s(literal -1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal -1/2 binary64)))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))))) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/2 binary64))))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/4 binary64))) (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 1/2 binary64)))
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64)))) (sqrt.f64 (fma.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 #s(literal 2 binary64) re) (-.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re #s(literal 4 binary64))))) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(/.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))))) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) #s(literal 2 binary64))) (sqrt.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 2 binary64))) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))))) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/4 binary64)) (pow.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64))) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)))
(+.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 2 binary64) re))
(+.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(-.f64 (/.f64 (*.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re))) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (/.f64 (*.f64 re (*.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(fma.f64 #s(literal 2 binary64) re (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(fma.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 #s(literal 2 binary64) re))
(fma.f64 re #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(fma.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) re))
(fma.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) re))
(fma.f64 (*.f64 #s(literal 2 binary64) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64))) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 #s(literal 2 binary64) re))
(/.f64 #s(literal 2 binary64) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 #s(literal 2 binary64) re) (-.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (-.f64 (*.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re #s(literal 4 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))) (*.f64 #s(literal 2 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))) (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) (*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 2 binary64))))
(/.f64 (fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64))) (fma.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 #s(literal 2 binary64) re) (-.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 (-.f64 (*.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re #s(literal 4 binary64)))) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re)))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))
(/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
(/.f64 (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) #s(literal 2 binary64)) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 2 binary64)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
(/.f64 (neg.f64 (fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64)))) (neg.f64 (fma.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 #s(literal 2 binary64) re) (-.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re #s(literal 4 binary64))))) (neg.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))))) (+.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) re))
(/.f64 (neg.f64 (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 2 binary64))) (+.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) re))
(/.f64 (fma.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 8 binary64))) (fma.f64 re (*.f64 re #s(literal 4 binary64)) (-.f64 (*.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re))) (*.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 (-.f64 (*.f64 re (*.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re)))) (-.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))))) (+.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) re))
(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re)))) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re)))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) #s(literal 2 binary64)) (+.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) re))
(/.f64 (*.f64 (-.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re))) #s(literal 2 binary64)) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64))
(*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64)))
(*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 2 binary64)))
(*.f64 (fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 8 binary64) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 #s(literal 2 binary64) re) (-.f64 (*.f64 #s(literal 2 binary64) re) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(*.f64 (-.f64 (*.f64 #s(literal 4 binary64) (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(*.f64 (*.f64 #s(literal 2 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(*.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(*.f64 (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re)))) (fma.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) (*.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (*.f64 re re) (*.f64 (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))) (fma.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (fma.f64 im im (*.f64 re re))))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))) (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))) (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 re re)) re))) (fma.f64 im im (fma.f64 re re (*.f64 re (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(*.f64 (/.f64 (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) #s(literal 2 binary64)) (fma.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) (*.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (*.f64 re re) (*.f64 (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))) (fma.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (fma.f64 im im (*.f64 re re))))))
(*.f64 (/.f64 (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) #s(literal 2 binary64)) (*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))) (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))) (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 2 binary64)) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 2 binary64)) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 re re)) re))) (fma.f64 im im (fma.f64 re re (*.f64 re (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)
(+.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(-.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(-.f64 (/.f64 (*.f64 re re) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(fma.f64 re #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(fma.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(fma.f64 #s(literal 1 binary64) re (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) re) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(fma.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/2 binary64)) re)
(fma.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))) re)
(fma.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))) re)
(fma.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)) re)
(fma.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)))) re)
(fma.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)))) re)
(fma.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)) re)
(fma.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) re)
(fma.f64 (pow.f64 re #s(literal 1/2 binary64)) (pow.f64 re #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(fma.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(fma.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 re re)) re))) (fma.f64 im im (fma.f64 re re (*.f64 re (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (neg.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(neg.f64 (/.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))))
(neg.f64 (/.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) (+.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) re)))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re)))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (-.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re)))))
(/.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re)))) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (+.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) re))
(/.f64 (fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))) (fma.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 re re)) re))))
(/.f64 (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) (fma.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 re re) (fma.f64 re re (fma.f64 im im (*.f64 re re)))))))
(/.f64 (-.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re))) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (fma.f64 re re (fma.f64 im im (*.f64 re re))) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (*.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) (fma.f64 re re (fma.f64 im im (*.f64 re re)))))
(/.f64 (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (*.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) (*.f64 re re))) (*.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 (*.f64 (fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 re re)) re)) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 re re) (fma.f64 re re (fma.f64 im im (*.f64 re re))))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 (*.f64 (*.f64 (fma.f64 re re (fma.f64 im im (*.f64 re re))) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re re (fma.f64 im im (*.f64 re re))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))))) (neg.f64 (+.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) re)))
(/.f64 (neg.f64 (-.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re)))) (neg.f64 (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 3 binary64))) (fma.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (fma.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))))
(/.f64 (-.f64 (*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (*.f64 (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))) (+.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (/.f64 (*.f64 re re) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(/.f64 (*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) #s(literal 1 binary64)) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1 binary64)) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
(/.f64 (*.f64 (fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))) (fma.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 re re)) re)))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (fma.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 re re) (fma.f64 re re (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re re (fma.f64 im im (*.f64 re re))) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (fma.f64 re re (fma.f64 im im (*.f64 re re))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64))
(*.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(*.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))))
(*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))) (*.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))))
(*.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) re)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re)))) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))))
(*.f64 (-.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1 binary64) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re)))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (/.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) (fma.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) (*.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (*.f64 re re) (*.f64 (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))) (fma.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (-.f64 (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (fma.f64 im im (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))) (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))) (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 re (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 (+.f64 im re) (-.f64 im re))) (fma.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 re re)) re))) (fma.f64 im im (fma.f64 re re (*.f64 re (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(*.f64 re #s(literal 4 binary64))
(*.f64 #s(literal 4 binary64) re)
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(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 re)) im)
(hypot.f64 (exp.f64 (log.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)))
(fabs.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))))
(/.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 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))))
(/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.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)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re)))) (sqrt.f64 (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(/.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)))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(*.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 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (/.f64 (*.f64 (*.f64 im 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)))))
(exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #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/2 binary64)))
(fabs.f64 (fma.f64 im im (*.f64 re re)))
(-.f64 (/.f64 (*.f64 (*.f64 im 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 im re) (-.f64 re im))) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 re im))))
(sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(fma.f64 (*.f64 (*.f64 im 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 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)) (*.f64 re 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 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 (*.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 (*.f64 im 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 (*.f64 im im) (*.f64 im im)) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re 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)))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))))
(neg.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re))) (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))
(/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re))) (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re)))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (*.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))) (fma.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))))))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))) (fma.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))) (*.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))) (*.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im)))))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (+.f64 im re) (-.f64 re im)))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 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 (*.f64 im 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 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))) (*.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))) (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (*.f64 (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))) (*.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.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 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re re) (*.f64 (*.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 im) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re))) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im 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 im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1 binary64)) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1 binary64)) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re)))) (neg.f64 (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 im 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 (*.f64 im im) (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 im 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 (*.f64 im 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 (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 (*.f64 im 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))))) (+.f64 (/.f64 (*.f64 (*.f64 im 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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (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 (*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re re) (*.f64 (*.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 (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))) (fma.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 (*.f64 im 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 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im 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 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (+.f64 im re)) (-.f64 im re))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1 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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(*.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(*.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 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))))))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (+.f64 (-.f64 #s(literal 0 binary64) im) re))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))))
(*.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 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (pow.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im)))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1 binary64)))
(*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (+.f64 im re))
(*.f64 (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (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 (*.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 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (fma.f64 (*.f64 im im) (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))) (-.f64 (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (*.f64 im im) (*.f64 im im))))))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im im)))) (*.f64 (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (-.f64 re im)) (*.f64 (*.f64 im im) (*.f64 im im))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))
(*.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 (fma.f64 im im (*.f64 re (+.f64 im re))) (-.f64 im re)))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re)))))

simplify476.0ms (4.9%)

Memory
-29.7MiB live, 590.7MiB allocated
Algorithm
1×egg-herbie
Rules
8 792×accelerator-lowering-fma.f32
8 792×accelerator-lowering-fma.f64
6 314×+-lowering-+.f64
6 314×+-lowering-+.f32
6 192×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
09216346
130876001
080675685
Stop Event
1×iter limit
1×node limit
Counts
324 → 324
Calls
Call 1
Inputs
(* 1/2 (* (sqrt re) (sqrt 2)))
(+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (sqrt 2))))
(+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* -1/16 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))))))
(+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (sqrt 2))) (* 1/32 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 5))))))))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (sqrt 2)) (pow (sqrt -1) 4)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))) (* 1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))))))))
(* 1/2 (* (sqrt re) (sqrt 2)))
(* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))
(* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))))))
(* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (sqrt 2)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))))
(* -1/2 (* (sqrt re) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1 (* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))
(sqrt re)
(+ (sqrt re) (* 1/2 (* im (sqrt (/ 1 re)))))
(+ (sqrt re) (* im (+ (* -1/8 (* im (sqrt (/ 1 (pow re 3))))) (* 1/2 (sqrt (/ 1 re))))))
(+ (sqrt re) (* im (+ (* 1/2 (sqrt (/ 1 re))) (* im (+ (* -1/8 (sqrt (/ 1 (pow re 3)))) (* 1/16 (* im (sqrt (/ 1 (pow re 5))))))))))
(sqrt im)
(* im (+ (sqrt (/ 1 im)) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt -1) 4)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))
(sqrt im)
(+ (sqrt im) (* 1/2 (* (sqrt (/ 1 im)) re)))
(+ (sqrt im) (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (sqrt (/ 1 im))))))
(+ (sqrt im) (* re (+ (* 1/2 (sqrt (/ 1 im))) (* re (+ (* -1/8 (sqrt (/ 1 (pow im 3)))) (* 1/16 (* (sqrt (/ 1 (pow im 5))) re)))))))
(sqrt re)
(* re (+ (sqrt (/ 1 re)) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3))))))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (pow im 3) (sqrt (/ 1 (pow re 7))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))))
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(* -1 (* re (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))
(* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))
(* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (pow im 3) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(sqrt re)
(+ (sqrt re) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))))
(+ (sqrt re) (* (pow im 2) (+ (* -1/128 (* (pow im 2) (sqrt (/ 1 (pow re 7))))) (* 1/8 (sqrt (/ 1 (pow re 3)))))))
(+ (sqrt re) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/128 (sqrt (/ 1 (pow re 7)))) (* 1/1024 (* (pow im 2) (sqrt (/ 1 (pow re 11))))))))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* im (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))
(* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))
(* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (+ (* 2 (* (/ 1 (pow im 6)) (sqrt (pow re 11)))) (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))
(* -1/2 (* im (sqrt (/ 1 re))))
(* -1 (* im (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))
(* -1 (* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))
(* -1 (* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (+ (* 2 (* (/ 1 (pow im 6)) (sqrt (pow re 11)))) (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))))
(* 1/2 (* im (sqrt (/ 1 re))))
(/ (+ (* 1/2 (* im (sqrt re))) (* (/ 1 im) (sqrt (pow re 5)))) re)
(/ (+ (* 1/2 (* im (sqrt re))) (* (pow re 3) (+ (* -1 (* (/ 1 (pow im 3)) (sqrt (pow re 3)))) (* (/ 1 im) (sqrt (/ 1 re)))))) re)
(/ (+ (* 1/2 (* im (sqrt re))) (* (pow re 3) (+ (* (/ 1 im) (sqrt (/ 1 re))) (* (pow re 3) (+ (* -1 (* (/ 1 (pow im 3)) (sqrt (/ 1 (pow re 3))))) (* 2 (* (/ 1 (pow im 5)) (sqrt re)))))))) re)
(sqrt re)
(* re (+ (sqrt (/ 1 re)) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5)))))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/128 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/128 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/1024 (* (pow im 6) (sqrt (/ 1 (pow re 13))))) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5)))))))))
(* -1/2 (* (sqrt re) (* (sqrt -4) (sqrt -1))))
(* -1 (* re (+ (* 1/4 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1)))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1/4 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re))) (* 1/16 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1)))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (pow re 3)))) (* 1/32 (* (/ (* (pow im 6) (sqrt -1)) (pow (sqrt -4) 5)) (sqrt (/ 1 re))))) (pow re 3))) (* -1/4 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re)))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1)))))))
(* 2 (sqrt re))
(+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 2 (sqrt re)))
(+ (* 2 (sqrt re)) (* (pow im 2) (+ (* -1/64 (* (pow im 2) (sqrt (/ 1 (pow re 7))))) (* 1/4 (sqrt (/ 1 (pow re 3)))))))
(+ (* 2 (sqrt re)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/64 (sqrt (/ 1 (pow re 7)))) (* 1/512 (* (pow im 2) (sqrt (/ 1 (pow re 11))))))))))
(* im (sqrt (/ 1 re)))
(* im (+ (sqrt (/ 1 re)) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))
(* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))
(* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))) (* 4 (* (/ 1 (pow im 6)) (sqrt (pow re 11))))))))
(* -1 (* im (sqrt (/ 1 re))))
(* -1 (* im (+ (sqrt (/ 1 re)) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))
(* -1 (* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))))
(* -1 (* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))) (* 4 (* (/ 1 (pow im 6)) (sqrt (pow re 11)))))))))
(* im (sqrt (/ 1 re)))
(/ (+ (* 2 (* (/ 1 im) (sqrt (pow re 5)))) (* im (sqrt re))) re)
(/ (+ (* im (sqrt re)) (* (pow re 3) (+ (* -2 (* (/ 1 (pow im 3)) (sqrt (pow re 3)))) (* 2 (* (/ 1 im) (sqrt (/ 1 re))))))) re)
(/ (+ (* im (sqrt re)) (* (pow re 3) (+ (* 2 (* (/ 1 im) (sqrt (/ 1 re)))) (* (pow re 3) (+ (* -2 (* (/ 1 (pow im 3)) (sqrt (/ 1 (pow re 3))))) (* 4 (* (/ 1 (pow im 5)) (sqrt re)))))))) re)
(* 2 (sqrt re))
(* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 2 (sqrt (/ 1 re)))))
(* re (+ (* -1/64 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 2 (sqrt (/ 1 re))))))
(* re (+ (* -1/64 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/512 (* (pow im 6) (sqrt (/ 1 (pow re 13))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 2 (sqrt (/ 1 re)))))))
(* -1 (* (sqrt re) (* (sqrt -4) (sqrt -1))))
(* -1 (* re (+ (* 1/2 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1/2 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re))) (* 1/8 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1 (/ (+ (* -1/8 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (pow re 3)))) (* 1/16 (* (/ (* (pow im 6) (sqrt -1)) (pow (sqrt -4) 5)) (sqrt (/ 1 re))))) (pow re 3))) (* -1/2 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re)))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1))))))
(* 4 re)
(+ (* 4 re) (/ (pow im 2) re))
(+ (* 4 re) (/ (pow im 2) re))
(+ (* 4 re) (/ (pow im 2) re))
(/ (pow im 2) re)
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(/ (pow im 2) re)
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(/ (pow im 2) re)
(/ (+ (* 4 (pow re 2)) (pow im 2)) re)
(/ (+ (* 4 (pow re 2)) (pow im 2)) re)
(/ (+ (* 4 (pow re 2)) (pow im 2)) re)
(* 4 re)
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(* 4 re)
(* -1 (* re (- (* -1 (/ (pow im 2) (pow re 2))) 4)))
(* -1 (* re (- (* -1 (/ (pow im 2) (pow re 2))) 4)))
(* -1 (* re (- (* -1 (/ (pow im 2) (pow re 2))) 4)))
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))
(+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))))
(+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* -1/4 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/8 (sqrt (/ 1 (pow re 3)))))))
(+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/4 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/4 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(* -1/2 (* (sqrt im) (* (sqrt -1) (sqrt 2))))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))
(* -1 (* im (+ (* -1 (/ (+ (* 1/16 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))))
(* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))
(* re (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))
(* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))
(* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/64 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))))
(* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(+ (* 1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/1024 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(* (sqrt re) (pow (sqrt 2) 2))
(+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* (sqrt re) (pow (sqrt 2) 2)))
(+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/4 (sqrt (/ 1 (pow re 3)))))))
(+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/2 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))
(* (sqrt im) (sqrt 2))
(* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))
(* -1 (* (sqrt im) (* (sqrt -1) (sqrt 2))))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))
(* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(* -1 (* im (+ (* -1 (/ (+ (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/4 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(* (sqrt im) (sqrt 2))
(+ (* 1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))
(+ (* re (+ (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))) (* (sqrt im) (sqrt 2)))
(* (sqrt re) (pow (sqrt 2) 2))
(* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))
(* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))
(* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/32 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))
(* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))
(+ (* 1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/512 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(* 4 re)
(+ (* 4 re) (/ (pow im 2) re))
(+ (* 4 re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re))))
(+ (* 4 re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re))))
(* 2 im)
(* im (+ 2 (* 2 (/ re im))))
(* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))
(* im (+ 2 (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2))))))
(* -2 im)
(* -1 (* im (+ 2 (* -2 (/ re im)))))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (pow re 2) im)) (* 2 re)) im)))))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im)) (* 2 re)) im)))))
(* 2 im)
(+ (* 2 im) (* 2 re))
(+ (* 2 im) (* re (+ 2 (/ re im))))
(+ (* 2 im) (* re (+ 2 (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))))))
(* 4 re)
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))))
(* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/8 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))))
(* -1 (/ (pow im 2) re))
(* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re))
(* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re))
(* -1 (/ (+ (* -1 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2)))) re))
(* 2 re)
(+ (* 1/2 (/ (pow im 2) re)) (* 2 re))
(+ (* 2 re) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ (* 2 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 (/ re im)))
(* im (+ 1 (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im)))))
(* -1 im)
(* -1 (* im (+ 1 (* -1 (/ re im)))))
(* -1 (* im (+ 1 (* -1 (/ (+ re (* -1/2 (/ (pow re 2) im))) im)))))
(* -1 (* im (+ 1 (* -1 (/ (+ re (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im))) im)))))
im
(+ im re)
(+ im (* re (+ 1 (* 1/2 (/ re im)))))
(+ im (* re (+ 1 (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
(* 2 re)
(* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1/2 (/ (pow im 2) re))
(* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re))
(* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re))
(* -1 (/ (+ (* -1/2 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2))))) re))
(* 4 re)
(* 4 re)
(* 4 re)
(* 4 re)
(* 4 re)
(* 4 re)
(* 4 re)
(* 4 re)
(* 4 re)
(* 4 re)
(* 4 re)
(* 4 re)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
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))))
Outputs
(* 1/2 (* (sqrt re) (sqrt 2)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64)))
(+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (sqrt 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 2 binary64))) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* -1/16 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))))))
(fma.f64 im (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
(+ (* 1/2 (* (sqrt re) (sqrt 2))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (sqrt 2))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (sqrt 2))) (* 1/32 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 5))))))))))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 #s(literal 1/32 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))
(*.f64 im (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(*.f64 im (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (*.f64 (*.f64 #s(literal -1/16 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 re re))))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(*.f64 im (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 re re))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (*.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64))))) (sqrt.f64 #s(literal 2 binary64))))))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (neg.f64 (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64))))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1 binary64))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(*.f64 (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 (*.f64 re re) #s(literal -1 binary64)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1 binary64))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64))))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (sqrt 2)) (pow (sqrt -1) 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (sqrt 2)) (pow (sqrt -1) 4)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))
(*.f64 (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 (*.f64 re re) #s(literal -1 binary64)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1 binary64))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (/.f64 (*.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64))))) (sqrt.f64 #s(literal 2 binary64)))) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))
(fma.f64 re (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))) (* 1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))))))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))))
(* 1/2 (* (sqrt re) (sqrt 2)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64)))
(* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))
(*.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))))))
(* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2))))))
(*.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (*.f64 #s(literal -1/16 binary64) (*.f64 (*.f64 im im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))))))))
(* re (+ (* -1/16 (* (* (pow im 2) (sqrt 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (sqrt 2)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt 2)))))))
(*.f64 re (fma.f64 #s(literal -1/16 binary64) (*.f64 (*.f64 im im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))) (fma.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))))))))
(* -1/2 (* (sqrt re) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (neg.f64 (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
(* -1 (* re (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(*.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1 binary64)) (fma.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 (*.f64 im im) #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt 2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))
(*.f64 (fma.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 (*.f64 im im) #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal -1 binary64)) (fma.f64 (*.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 im (*.f64 im im)) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))))))) (-.f64 #s(literal 0 binary64) re))
(sqrt re)
(sqrt.f64 re)
(+ (sqrt re) (* 1/2 (* im (sqrt (/ 1 re)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 re))
(+ (sqrt re) (* im (+ (* -1/8 (* im (sqrt (/ 1 (pow re 3))))) (* 1/2 (sqrt (/ 1 re))))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal -1/8 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (sqrt.f64 re))
(+ (sqrt re) (* im (+ (* 1/2 (sqrt (/ 1 re))) (* im (+ (* -1/8 (sqrt (/ 1 (pow re 3)))) (* 1/16 (* im (sqrt (/ 1 (pow re 5))))))))))
(fma.f64 im (fma.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) #s(literal -1/8 binary64) (*.f64 (*.f64 #s(literal 1/16 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 re))
(sqrt im)
(sqrt.f64 im)
(* im (+ (sqrt (/ 1 im)) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (fma.f64 #s(literal -1/8 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))))
(*.f64 im (+.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 #s(literal 1/16 binary64) (*.f64 (*.f64 re (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64))))))) (fma.f64 #s(literal -1/8 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(*.f64 #s(literal 1 binary64) (sqrt.f64 im))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1 binary64))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1 binary64) (*.f64 #s(literal -1/8 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) #s(literal -1 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt -1) 4)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))
(*.f64 (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64))))) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1 binary64) (*.f64 #s(literal -1/8 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) #s(literal -1 binary64))))))) (-.f64 #s(literal 0 binary64) im))
(sqrt im)
(sqrt.f64 im)
(+ (sqrt im) (* 1/2 (* (sqrt (/ 1 im)) re)))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (sqrt.f64 im))
(+ (sqrt im) (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (sqrt (/ 1 im))))))
(fma.f64 re (fma.f64 #s(literal -1/8 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (sqrt.f64 im))
(+ (sqrt im) (* re (+ (* 1/2 (sqrt (/ 1 im))) (* re (+ (* -1/8 (sqrt (/ 1 (pow im 3)))) (* 1/16 (* (sqrt (/ 1 (pow im 5))) re)))))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal 1/16 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) #s(literal -1/8 binary64))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (sqrt.f64 im))
(sqrt re)
(sqrt.f64 re)
(* re (+ (sqrt (/ 1 re)) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))
(*.f64 re (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3))))))))
(*.f64 re (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (pow im 3) (sqrt (/ 1 (pow re 7))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))))
(*.f64 re (+.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 im (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))))
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(sqrt.f64 re)
(* -1 (* re (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64) (*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 im im)) #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))))))
(* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (pow im 3) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))))
(*.f64 (fma.f64 (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 im im)) #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (fma.f64 (/.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 im (*.f64 im im))) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64) (*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))))) (-.f64 #s(literal 0 binary64) re))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (neg.f64 (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (neg.f64 (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (neg.f64 (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (neg.f64 (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64))))
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(*.f64 #s(literal 1 binary64) (sqrt.f64 im))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(*.f64 #s(literal 1 binary64) (sqrt.f64 im))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(*.f64 #s(literal 1 binary64) (sqrt.f64 im))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(*.f64 #s(literal 1 binary64) (sqrt.f64 im))
(sqrt re)
(sqrt.f64 re)
(+ (sqrt re) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))))
(fma.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 re))
(+ (sqrt re) (* (pow im 2) (+ (* -1/128 (* (pow im 2) (sqrt (/ 1 (pow re 7))))) (* 1/8 (sqrt (/ 1 (pow re 3)))))))
(fma.f64 (*.f64 im im) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64) (*.f64 (*.f64 #s(literal -1/128 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))))) (sqrt.f64 re))
(+ (sqrt re) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/128 (sqrt (/ 1 (pow re 7)))) (* 1/1024 (* (pow im 2) (sqrt (/ 1 (pow re 11))))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) #s(literal -1/128 binary64) (*.f64 (*.f64 #s(literal 1/1024 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 11 binary64)))))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (sqrt.f64 re))
(* 1/2 (* im (sqrt (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 im im))))
(* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))
(*.f64 im (-.f64 (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 im im))) (/.f64 (sqrt.f64 (pow.f64 re #s(literal 7 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (+ (* 2 (* (/ 1 (pow im 6)) (sqrt (pow re 11)))) (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))
(*.f64 im (-.f64 (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 2 binary64) (/.f64 (sqrt.f64 (pow.f64 re #s(literal 11 binary64))) (pow.f64 im #s(literal 6 binary64))) (/.f64 (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 im im)))) (/.f64 (sqrt.f64 (pow.f64 re #s(literal 7 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(* -1/2 (* im (sqrt (/ 1 re))))
(*.f64 (*.f64 #s(literal -1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* -1 (* im (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 im im))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))
(*.f64 (-.f64 (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 im im))) (/.f64 (sqrt.f64 (pow.f64 re #s(literal 7 binary64))) (pow.f64 im #s(literal 4 binary64)))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 1/2 (sqrt (/ 1 re))) (+ (* 2 (* (/ 1 (pow im 6)) (sqrt (pow re 11)))) (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))))
(*.f64 (-.f64 (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 2 binary64) (/.f64 (sqrt.f64 (pow.f64 re #s(literal 11 binary64))) (pow.f64 im #s(literal 6 binary64))) (/.f64 (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 im im)))) (/.f64 (sqrt.f64 (pow.f64 re #s(literal 7 binary64))) (pow.f64 im #s(literal 4 binary64)))) (-.f64 #s(literal 0 binary64) im))
(* 1/2 (* im (sqrt (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(/ (+ (* 1/2 (* im (sqrt re))) (* (/ 1 im) (sqrt (pow re 5)))) re)
(/.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) im) (/.f64 (sqrt.f64 (pow.f64 re #s(literal 5 binary64))) im)) re)
(/ (+ (* 1/2 (* im (sqrt re))) (* (pow re 3) (+ (* -1 (* (/ 1 (pow im 3)) (sqrt (pow re 3)))) (* (/ 1 im) (sqrt (/ 1 re)))))) re)
(/.f64 (fma.f64 (*.f64 re (*.f64 re re)) (-.f64 (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) im) (/.f64 (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) im))) re)
(/ (+ (* 1/2 (* im (sqrt re))) (* (pow re 3) (+ (* (/ 1 im) (sqrt (/ 1 re))) (* (pow re 3) (+ (* -1 (* (/ 1 (pow im 3)) (sqrt (/ 1 (pow re 3))))) (* 2 (* (/ 1 (pow im 5)) (sqrt re)))))))) re)
(/.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) im) (*.f64 (*.f64 re (*.f64 re re)) (fma.f64 (*.f64 re (*.f64 re re)) (-.f64 (/.f64 (*.f64 (sqrt.f64 re) #s(literal 2 binary64)) (pow.f64 im #s(literal 5 binary64))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im im)))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) im)))) re)
(sqrt re)
(sqrt.f64 re)
(* re (+ (sqrt (/ 1 re)) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5)))))))
(*.f64 re (fma.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/128 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))))))
(*.f64 re (fma.f64 (*.f64 #s(literal -1/128 binary64) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (fma.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/128 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/1024 (* (pow im 6) (sqrt (/ 1 (pow re 13))))) (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5)))))))))
(*.f64 re (+.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (*.f64 #s(literal 1/1024 binary64) (pow.f64 im #s(literal 6 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 13 binary64)))) (fma.f64 (*.f64 #s(literal -1/128 binary64) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))))
(* -1/2 (* (sqrt re) (* (sqrt -4) (sqrt -1))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 re)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -4 binary64))))
(* -1 (* re (+ (* 1/4 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1)))))))
(*.f64 (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 im im)) (sqrt.f64 #s(literal -4 binary64)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -4 binary64))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1 (/ (+ (* -1/4 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re))) (* 1/16 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1)))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -4 binary64)))) (/.f64 (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (*.f64 (sqrt.f64 #s(literal -4 binary64)) #s(literal -4 binary64))) (*.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 im im))) (sqrt.f64 #s(literal -4 binary64))))) (*.f64 re (*.f64 re re))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (pow re 3)))) (* 1/32 (* (/ (* (pow im 6) (sqrt -1)) (pow (sqrt -4) 5)) (sqrt (/ 1 re))))) (pow re 3))) (* -1/4 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re)))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1)))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (-.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -4 binary64)))) (/.f64 (-.f64 (*.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 im im))) (sqrt.f64 #s(literal -4 binary64)))) (/.f64 (fma.f64 #s(literal 1/32 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (sqrt.f64 #s(literal -4 binary64)) #s(literal 5 binary64)))) (*.f64 #s(literal -1/16 binary64) (/.f64 (*.f64 (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (sqrt.f64 #s(literal -4 binary64)) #s(literal -4 binary64))))) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re))))))
(* 2 (sqrt re))
(*.f64 (sqrt.f64 re) #s(literal 2 binary64))
(+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 2 (sqrt re)))
(fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 im im)) (*.f64 (sqrt.f64 re) #s(literal 2 binary64)))
(+ (* 2 (sqrt re)) (* (pow im 2) (+ (* -1/64 (* (pow im 2) (sqrt (/ 1 (pow re 7))))) (* 1/4 (sqrt (/ 1 (pow re 3)))))))
(fma.f64 (sqrt.f64 re) #s(literal 2 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 #s(literal -1/64 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64))))))))
(+ (* 2 (sqrt re)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/64 (sqrt (/ 1 (pow re 7)))) (* 1/512 (* (pow im 2) (sqrt (/ 1 (pow re 11))))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) #s(literal -1/64 binary64) (*.f64 (*.f64 #s(literal 1/512 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 11 binary64)))))) (*.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 (sqrt.f64 re) #s(literal 2 binary64)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (+ (sqrt (/ 1 re)) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))
(*.f64 im (fma.f64 (/.f64 #s(literal 2 binary64) (*.f64 im im)) (sqrt.f64 (*.f64 re (*.f64 re re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))
(*.f64 im (fma.f64 (/.f64 #s(literal 2 binary64) (*.f64 im im)) (sqrt.f64 (*.f64 re (*.f64 re re))) (fma.f64 (/.f64 #s(literal -2 binary64) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (pow.f64 re #s(literal 7 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))) (* 4 (* (/ 1 (pow im 6)) (sqrt (pow re 11))))))))
(*.f64 im (+.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (/.f64 #s(literal -2 binary64) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (pow.f64 re #s(literal 7 binary64))) (fma.f64 (/.f64 #s(literal 2 binary64) (*.f64 im im)) (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 4 binary64) (pow.f64 im #s(literal 6 binary64))) (sqrt.f64 (pow.f64 re #s(literal 11 binary64))))))))
(* -1 (* im (sqrt (/ 1 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (sqrt (/ 1 re)) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))))))
(*.f64 (fma.f64 (/.f64 #s(literal 2 binary64) (*.f64 im im)) (sqrt.f64 (*.f64 re (*.f64 re re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3))))))))
(*.f64 (fma.f64 (/.f64 #s(literal 2 binary64) (*.f64 im im)) (sqrt.f64 (*.f64 re (*.f64 re re))) (fma.f64 (/.f64 #s(literal -2 binary64) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (pow.f64 re #s(literal 7 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (sqrt (/ 1 re)) (+ (* -2 (* (/ 1 (pow im 4)) (sqrt (pow re 7)))) (+ (* 2 (* (/ 1 (pow im 2)) (sqrt (pow re 3)))) (* 4 (* (/ 1 (pow im 6)) (sqrt (pow re 11)))))))))
(*.f64 (+.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (/.f64 #s(literal -2 binary64) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (pow.f64 re #s(literal 7 binary64))) (fma.f64 (/.f64 #s(literal 2 binary64) (*.f64 im im)) (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 4 binary64) (pow.f64 im #s(literal 6 binary64))) (sqrt.f64 (pow.f64 re #s(literal 11 binary64))))))) (-.f64 #s(literal 0 binary64) im))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(/ (+ (* 2 (* (/ 1 im) (sqrt (pow re 5)))) (* im (sqrt re))) re)
(/.f64 (fma.f64 (/.f64 #s(literal 2 binary64) im) (sqrt.f64 (pow.f64 re #s(literal 5 binary64))) (*.f64 (sqrt.f64 re) im)) re)
(/ (+ (* im (sqrt re)) (* (pow re 3) (+ (* -2 (* (/ 1 (pow im 3)) (sqrt (pow re 3)))) (* 2 (* (/ 1 im) (sqrt (/ 1 re))))))) re)
(/.f64 (fma.f64 (sqrt.f64 re) im (*.f64 (*.f64 re (*.f64 re re)) (fma.f64 (/.f64 #s(literal -2 binary64) (*.f64 im (*.f64 im im))) (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 (/.f64 #s(literal 2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))) re)
(/ (+ (* im (sqrt re)) (* (pow re 3) (+ (* 2 (* (/ 1 im) (sqrt (/ 1 re)))) (* (pow re 3) (+ (* -2 (* (/ 1 (pow im 3)) (sqrt (/ 1 (pow re 3))))) (* 4 (* (/ 1 (pow im 5)) (sqrt re)))))))) re)
(/.f64 (fma.f64 (*.f64 re (*.f64 re re)) (fma.f64 (*.f64 re (*.f64 re re)) (fma.f64 #s(literal 4 binary64) (/.f64 (sqrt.f64 re) (pow.f64 im #s(literal 5 binary64))) (*.f64 (/.f64 #s(literal -2 binary64) (*.f64 im (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 (/.f64 #s(literal 2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (sqrt.f64 re) im)) re)
(* 2 (sqrt re))
(*.f64 (sqrt.f64 re) #s(literal 2 binary64))
(* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 2 (sqrt (/ 1 re)))))
(*.f64 re (fma.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
(* re (+ (* -1/64 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 2 (sqrt (/ 1 re))))))
(*.f64 re (fma.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (*.f64 #s(literal -1/64 binary64) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))))))
(* re (+ (* -1/64 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/512 (* (pow im 6) (sqrt (/ 1 (pow re 13))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 2 (sqrt (/ 1 re)))))))
(*.f64 re (fma.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64))))) #s(literal -1/64 binary64) (fma.f64 (*.f64 #s(literal 1/512 binary64) (pow.f64 im #s(literal 6 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 13 binary64)))) (fma.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))))
(* -1 (* (sqrt re) (* (sqrt -4) (sqrt -1))))
(*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -4 binary64))) (neg.f64 (sqrt.f64 re)))
(* -1 (* re (+ (* 1/2 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1))))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 im im)) (sqrt.f64 #s(literal -4 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -4 binary64))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1 (/ (+ (* -1/2 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re))) (* 1/8 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (-.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -4 binary64)))) (/.f64 (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (*.f64 (sqrt.f64 #s(literal -4 binary64)) #s(literal -4 binary64))) (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 im im))) (sqrt.f64 #s(literal -4 binary64))))) (*.f64 re (*.f64 re re))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1 (/ (+ (* -1/8 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt -4) 3)) (sqrt (pow re 3)))) (* 1/16 (* (/ (* (pow im 6) (sqrt -1)) (pow (sqrt -4) 5)) (sqrt (/ 1 re))))) (pow re 3))) (* -1/2 (* (/ (* (pow im 2) (sqrt -1)) (sqrt -4)) (sqrt re)))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -4) (sqrt -1))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (-.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -4 binary64)))) (/.f64 (-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (sqrt.f64 re) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 im im))) (sqrt.f64 #s(literal -4 binary64)))) (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (sqrt.f64 (*.f64 re (*.f64 re re))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 (sqrt.f64 #s(literal -4 binary64)) #s(literal -4 binary64))) (*.f64 (*.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (sqrt.f64 #s(literal -4 binary64)) #s(literal 5 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re))))))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(+ (* 4 re) (/ (pow im 2) re))
(fma.f64 re #s(literal 4 binary64) (/.f64 (*.f64 im im) re))
(+ (* 4 re) (/ (pow im 2) re))
(fma.f64 re #s(literal 4 binary64) (/.f64 (*.f64 im im) re))
(+ (* 4 re) (/ (pow im 2) re))
(fma.f64 re #s(literal 4 binary64) (/.f64 (*.f64 im im) re))
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 #s(literal 4 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)))
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 #s(literal 4 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)))
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 #s(literal 4 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)))
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 #s(literal 4 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)))
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 #s(literal 4 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)))
(* (pow im 2) (+ (* 4 (/ re (pow im 2))) (/ 1 re)))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 #s(literal 4 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re)))
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (+ (* 4 (pow re 2)) (pow im 2)) re)
(/.f64 (fma.f64 im im (*.f64 (*.f64 re re) #s(literal 4 binary64))) re)
(/ (+ (* 4 (pow re 2)) (pow im 2)) re)
(/.f64 (fma.f64 im im (*.f64 (*.f64 re re) #s(literal 4 binary64))) re)
(/ (+ (* 4 (pow re 2)) (pow im 2)) re)
(/.f64 (fma.f64 im im (*.f64 (*.f64 re re) #s(literal 4 binary64))) re)
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 4 binary64)))
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 4 binary64)))
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 4 binary64)))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* -1 (* re (- (* -1 (/ (pow im 2) (pow re 2))) 4)))
(*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (- (* -1 (/ (pow im 2) (pow re 2))) 4)))
(*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (- (* -1 (/ (pow im 2) (pow re 2))) 4)))
(*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (-.f64 #s(literal 0 binary64) re))
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) #s(literal 2 binary64)))
(+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))))
(+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* -1/4 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/8 (sqrt (/ 1 (pow re 3)))))))
(fma.f64 (*.f64 im im) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64) (*.f64 #s(literal -1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) #s(literal 2 binary64))))
(+ (* 1/2 (* (sqrt re) (pow (sqrt 2) 2))) (* (pow im 2) (+ (* 1/8 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/4 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/4 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))
(fma.f64 (*.f64 im im) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64) (*.f64 (*.f64 im im) (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im im) (-.f64 (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (*.f64 #s(literal -1/8 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))) (*.f64 re re)))))) (*.f64 (*.f64 #s(literal -1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) #s(literal 2 binary64))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))
(*.f64 im (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))))
(* im (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(*.f64 im (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (*.f64 (*.f64 #s(literal 1/8 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 re re))))))
(* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(*.f64 im (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 re re))) #s(literal 1/16 binary64) (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))))
(* -1/2 (* (sqrt im) (* (sqrt -1) (sqrt 2))))
(*.f64 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64)))) (*.f64 #s(literal -1/8 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1 (/ (+ (* 1/16 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))))
(*.f64 (-.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64)))))) (*.f64 (*.f64 (sqrt.f64 im) (*.f64 (*.f64 re re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))))) (/.f64 #s(literal 3/16 binary64) (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) im))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(+ (* 1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)) (*.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))))))
(fma.f64 re (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal 1/16 binary64) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* 1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/32 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)) (*.f64 re (fma.f64 re (fma.f64 (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) #s(literal -1/32 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) #s(literal 1/16 binary64))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))))
(* 1/2 (* (sqrt re) (pow (sqrt 2) 2)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) #s(literal 2 binary64)))
(* re (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))
(*.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
(* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))
(*.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (fma.f64 (*.f64 #s(literal -1/32 binary64) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))))))
(* re (+ (* -1/32 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/64 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (fma.f64 #s(literal -1/32 binary64) (pow.f64 im #s(literal 4 binary64)) (/.f64 (*.f64 #s(literal -1/64 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 2 binary64))) (fma.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (*.f64 #s(literal 1/8 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))))))
(* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(*.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(+ (* 1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 #s(literal 1/32 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (/.f64 (*.f64 im (*.f64 im im)) (sqrt.f64 #s(literal 1/2 binary64)))))))
(+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (fma.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (/.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 #s(literal 1/64 binary64) (*.f64 (*.f64 (pow.f64 im #s(literal 5 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal 1/2 binary64)))))) (*.f64 re (*.f64 re re))))
(+ (* -1 (/ (+ (* -1/32 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/1024 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/64 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* 1/2 (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (fma.f64 #s(literal 1/64 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (/.f64 (pow.f64 im #s(literal 5 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 #s(literal 1/1024 binary64) (*.f64 (pow.f64 im #s(literal 5 binary64)) (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 1/2 binary64))))))) (*.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (/.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 1/2 binary64)))))) (*.f64 re (*.f64 re re))))
(* (sqrt re) (pow (sqrt 2) 2))
(*.f64 (sqrt.f64 re) #s(literal 2 binary64))
(+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 3))))) (* (sqrt re) (pow (sqrt 2) 2)))
(fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 im im)) (*.f64 (sqrt.f64 re) #s(literal 2 binary64)))
(+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3))))) (sqrt (/ 1 re)))) (* 1/4 (sqrt (/ 1 (pow re 3)))))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im im) (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 (sqrt.f64 re) #s(literal 2 binary64)))
(+ (* (sqrt re) (pow (sqrt 2) 2)) (* (pow im 2) (+ (* 1/4 (sqrt (/ 1 (pow re 3)))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ 1 re)) (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))))) (* 1/2 (* (* (pow im 2) (- (* 1/16 (/ 1 (pow re 5))) (* -1/4 (/ (+ (* 1/16 (/ 1 (* (pow re 3) (pow (sqrt 2) 2)))) (* 1/8 (/ 1 (pow re 3)))) (* (pow re 2) (pow (sqrt 2) 2)))))) (sqrt (/ 1 re)))))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 im im) (-.f64 (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (*.f64 #s(literal -1/8 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))) (*.f64 re re)))))) (*.f64 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (+.f64 (/.f64 #s(literal 1/32 binary64) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/8 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 (sqrt.f64 re) #s(literal 2 binary64)))
(* (sqrt im) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))
(*.f64 im (fma.f64 (*.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 re re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))))
(* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))
(*.f64 im (fma.f64 (*.f64 #s(literal 1/8 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 re re)) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))))
(* -1 (* (sqrt im) (* (sqrt -1) (sqrt 2))))
(-.f64 #s(literal 0 binary64) (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(*.f64 (fma.f64 #s(literal -1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1 (/ (+ (* 1/8 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* 1/4 (* (sqrt im) (* (pow re 2) (* (sqrt -1) (sqrt 2)))))) (pow im 3))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(*.f64 (-.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64))))) (*.f64 (*.f64 (sqrt.f64 im) (*.f64 (*.f64 re re) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))))) (/.f64 #s(literal 3/8 binary64) (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) im))
(* (sqrt im) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(+ (* 1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(+ (* re (+ (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal 1/8 binary64) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(+ (* re (+ (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* re (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* re (sqrt 2)))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (sqrt 2))))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 re (fma.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) #s(literal 1/8 binary64) (*.f64 #s(literal -1/16 binary64) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(* (sqrt re) (pow (sqrt 2) 2))
(*.f64 (sqrt.f64 re) #s(literal 2 binary64))
(* re (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))
(*.f64 re (fma.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
(* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2)))))
(*.f64 re (fma.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (*.f64 #s(literal -1/16 binary64) (pow.f64 im #s(literal 4 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))))))
(* re (+ (* -1/16 (* (pow im 4) (sqrt (/ 1 (pow re 9))))) (+ (* -1/32 (* (/ (pow im 4) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/4 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (pow (sqrt 2) 2))))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (fma.f64 #s(literal -1/16 binary64) (pow.f64 im #s(literal 4 binary64)) (/.f64 (*.f64 #s(literal -1/32 binary64) (pow.f64 im #s(literal 4 binary64))) #s(literal 2 binary64))) (fma.f64 #s(literal 2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))))))
(* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re)))
(*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(+ (* 1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(fma.f64 #s(literal 1/16 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (/.f64 (*.f64 im (*.f64 im im)) (sqrt.f64 #s(literal 1/2 binary64))))) (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3)))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(-.f64 (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (/.f64 (fma.f64 #s(literal -1/16 binary64) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (/.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 (pow.f64 im #s(literal 5 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal 1/2 binary64)))))) (*.f64 re (*.f64 re re))))
(+ (* -1 (/ (+ (* -1/16 (* (/ (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt re))) (+ (* 1/512 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/32 (* (/ (* (pow im 5) (* (sqrt -1) (sqrt 2))) (sqrt 1/2)) (sqrt (/ 1 (pow re 3))))))) (pow re 3))) (* (* im (* (sqrt -1) (* (sqrt 1/2) (sqrt 2)))) (sqrt (/ 1 re))))
(-.f64 (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (/.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (fma.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (/.f64 (pow.f64 im #s(literal 5 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 #s(literal 1/512 binary64) (*.f64 (pow.f64 im #s(literal 5 binary64)) (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 1/2 binary64))))))) (*.f64 #s(literal -1/16 binary64) (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (/.f64 (sqrt.f64 re) (sqrt.f64 #s(literal 1/2 binary64)))))) (*.f64 re (*.f64 re re))))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(+ (* 4 re) (/ (pow im 2) re))
(fma.f64 re #s(literal 4 binary64) (/.f64 (*.f64 im im) re))
(+ (* 4 re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (*.f64 im (/.f64 im (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) re)) (*.f64 re #s(literal 4 binary64)))
(+ (* 4 re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re))))
(fma.f64 re #s(literal 4 binary64) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) re))))
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* im (+ 2 (* 2 (/ re im))))
(*.f64 im (fma.f64 #s(literal 2 binary64) (/.f64 re im) #s(literal 2 binary64)))
(* im (+ 2 (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2)))))
(*.f64 im (fma.f64 re (/.f64 re (*.f64 im im)) (fma.f64 #s(literal 2 binary64) (/.f64 re im) #s(literal 2 binary64))))
(* im (+ 2 (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 2 (/ re im)) (/ (pow re 2) (pow im 2))))))
(*.f64 im (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 re (/.f64 re (*.f64 im im)) (fma.f64 #s(literal 2 binary64) (/.f64 re im) #s(literal 2 binary64)))))
(* -2 im)
(*.f64 im #s(literal -2 binary64))
(* -1 (* im (+ 2 (* -2 (/ re im)))))
(*.f64 (fma.f64 #s(literal -2 binary64) (/.f64 re im) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (pow re 2) im)) (* 2 re)) im)))))
(*.f64 (-.f64 #s(literal 2 binary64) (/.f64 (-.f64 (*.f64 re #s(literal 2 binary64)) (/.f64 (*.f64 re re) im)) im)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im)) (* 2 re)) im)))))
(-.f64 #s(literal 0 binary64) (*.f64 im (-.f64 #s(literal 2 binary64) (/.f64 (-.f64 (*.f64 re #s(literal 2 binary64)) (/.f64 (fma.f64 re re (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 im im))) im)) im))))
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(+ (* 2 im) (* 2 re))
(*.f64 #s(literal 2 binary64) (+.f64 re im))
(+ (* 2 im) (* re (+ 2 (/ re im))))
(fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 #s(literal 2 binary64) im))
(+ (* 2 im) (* re (+ 2 (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1 binary64) im)) #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) im))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* re (+ 4 (/ (pow im 2) (pow re 2))))
(*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 4 binary64)))
(* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))))
(*.f64 re (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 4 binary64))))
(* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/8 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))))
(*.f64 re (+.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))))
(* -1 (/ (pow im 2) re))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re))
(/.f64 (fma.f64 im im (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 re re))) (-.f64 #s(literal 0 binary64) re))
(* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re))
(/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 re re)) (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64))) (*.f64 im im))) (-.f64 #s(literal 0 binary64) re))
(* -1 (/ (+ (* -1 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2)))) re))
(/.f64 (-.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 re re)) (fma.f64 #s(literal 1/8 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64))) (*.f64 im im))) (/.f64 (*.f64 (pow.f64 im #s(literal 8 binary64)) #s(literal 5/64 binary64)) (pow.f64 re #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) re))
(* 2 re)
(*.f64 re #s(literal 2 binary64))
(+ (* 1/2 (/ (pow im 2) re)) (* 2 re))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re) (*.f64 re #s(literal 2 binary64)))
(+ (* 2 re) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/8 binary64) (*.f64 im (/.f64 im (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 re #s(literal 2 binary64)))
(+ (* 2 re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 re #s(literal 2 binary64)))
im
(* im (+ 1 (/ re im)))
(fma.f64 im (/.f64 re im) im)
(* im (+ 1 (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 re im)) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (pow im 2))) (/ re im)))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 re im))) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (* -1 (/ re im)))))
(-.f64 #s(literal 0 binary64) (*.f64 im (-.f64 #s(literal 1 binary64) (/.f64 re im))))
(* -1 (* im (+ 1 (* -1 (/ (+ re (* -1/2 (/ (pow re 2) im))) im)))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) re) im)))
(* -1 (* im (+ 1 (* -1 (/ (+ re (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im))) im)))))
(-.f64 #s(literal 0 binary64) (*.f64 im (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 re (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 im im)) (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) im)) im))))
im
(+ im re)
(+.f64 re im)
(+ im (* re (+ 1 (* 1/2 (/ re im)))))
(fma.f64 re (fma.f64 #s(literal 1/2 binary64) (/.f64 re im) #s(literal 1 binary64)) im)
(+ im (* re (+ 1 (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) #s(literal 1 binary64)) im)
(* 2 re)
(*.f64 re #s(literal 2 binary64))
(* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2)))))
(*.f64 re (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 2 binary64)))
(* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 2 binary64))))
(* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 re (+.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 2 binary64))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))))
(* -1/2 (/ (pow im 2) re))
(*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re))
(* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re))
(-.f64 #s(literal 0 binary64) (/.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 im im) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 re re))) re))
(* -1 (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re))
(/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 re re)) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (*.f64 im im)))) (-.f64 #s(literal 0 binary64) re))
(* -1 (/ (+ (* -1/2 (/ (+ (* 1/64 (pow im 8)) (* 1/16 (pow im 8))) (pow re 6))) (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2))))) re))
(/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 8 binary64)) #s(literal 5/64 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 re re)) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 4 binary64))) (*.f64 #s(literal 1/2 binary64) (*.f64 im im))))) (-.f64 #s(literal 0 binary64) re))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
(* 4 re)
(*.f64 re #s(literal 4 binary64))
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 im im) (fma.f64 #s(literal -1/8 binary64) (*.f64 im (/.f64 im (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(*.f64 im (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 1 binary64)))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64))))
(* 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/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 1 binary64)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1 binary64)))))
(* -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 #s(literal 0 binary64) (fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 re re) (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)))))
(*.f64 re (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64)))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(*.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64))))
(* 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/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) re)
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(*.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(-.f64 #s(literal 0 binary64) (fma.f64 re (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) 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))))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64)))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64)))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64)))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64)))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64)))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(*.f64 (*.f64 im im) (fma.f64 re (/.f64 re (*.f64 im im)) #s(literal 1 binary64)))
(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))))
(*.f64 (*.f64 re re) (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64)))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64)))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64)))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64)))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64)))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(*.f64 (*.f64 re re) (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 1 binary64)))

eval153.0ms (1.6%)

Memory
12.0MiB live, 159.6MiB allocated
Compiler

Compiled 25 471 to 3 373 computations (86.8% saved)

prune161.0ms (1.7%)

Memory
0.5MiB live, 166.1MiB allocated
Pruning

16 alts after pruning (7 fresh and 9 done)

PrunedKeptTotal
New8251826
Fresh167
Picked055
Done044
Total82616842
Accuracy
99.4%
Counts
842 → 16
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓54.9%
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
▶51.7%
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
✓51.8%
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
▶14.7%
(*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
▶14.7%
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)))))
▶21.5%
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (neg.f64 (/.f64 im re)))))
✓52.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))))
✓29.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
✓13.3%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))))
▶17.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re)))))
39.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) re))))
41.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))) re))))
✓41.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
✓54.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
✓29.4%
(sqrt.f64 re)
✓5.4%
#s(literal 0 binary64)
Compiler

Compiled 295 to 212 computations (28.1% saved)

simplify38.0ms (0.4%)

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

Found 19 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re))))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)))))
✓cost-diff128
(neg.f64 (/.f64 #s(literal 1 binary64) re))
✓cost-diff896
(sqrt.f64 (*.f64 im im))
✓cost-diff0
(sqrt.f64 (-.f64 #s(literal 0 binary64) re))
✓cost-diff0
(/.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
✓cost-diff896
(sqrt.f64 (*.f64 im im))
✓cost-diff0
(sqrt.f64 (neg.f64 (/.f64 im re)))
✓cost-diff0
(sqrt.f64 im)
✓cost-diff0
(*.f64 (sqrt.f64 im) (sqrt.f64 (neg.f64 (/.f64 im re))))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (neg.f64 (/.f64 im re)))))
✓cost-diff-64
(*.f64 im (neg.f64 (/.f64 im re)))
✓cost-diff0
(/.f64 im re)
✓cost-diff0
(sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re))))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re)))))
✓cost-diff-64
(*.f64 im #s(literal 2 binary64))
✓cost-diff0
(sqrt.f64 (*.f64 im #s(literal 2 binary64)))
✓cost-diff0
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
Rules
304×*-lowering-*.f32
304×*-lowering-*.f64
184×accelerator-lowering-fma.f32
184×accelerator-lowering-fma.f64
100×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
029146
161146
2100146
3132146
4162146
5194146
6258146
7354146
8393146
9416146
10467146
11557146
12625146
13627146
0627146
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(* (sqrt (* im 2)) 1/2)
(sqrt (* im 2))
(* im 2)
im
2
1/2
(* 1/2 (sqrt (* im (neg (/ im re)))))
1/2
(sqrt (* im (neg (/ im re))))
(* im (neg (/ im re)))
im
(neg (/ im re))
(/ im re)
re
(* 1/2 (* (sqrt im) (sqrt (neg (/ im re)))))
1/2
(* (sqrt im) (sqrt (neg (/ im re))))
(sqrt im)
im
(sqrt (neg (/ im re)))
(neg (/ im re))
(/ im re)
re
(* 1/2 (/ (sqrt (* im im)) (sqrt (- 0 re))))
1/2
(/ (sqrt (* im im)) (sqrt (- 0 re)))
(sqrt (* im im))
(* im im)
im
(sqrt (- 0 re))
(- 0 re)
0
re
(* 1/2 (* (sqrt (* im im)) (sqrt (neg (/ 1 re)))))
1/2
(* (sqrt (* im im)) (sqrt (neg (/ 1 re))))
(sqrt (* im im))
(* im im)
im
(sqrt (neg (/ 1 re)))
(neg (/ 1 re))
(/ 1 re)
1
re
Outputs
(* (sqrt (* im 2)) 1/2)
(*.f64 (sqrt.f64 (fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))) #s(literal 1/2 binary64))
(sqrt (* im 2))
(sqrt.f64 (fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64)))
(* im 2)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
im
2
#s(literal 2 binary64)
1/2
#s(literal 1/2 binary64)
(* 1/2 (sqrt (* im (neg (/ im re)))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))))
1/2
#s(literal 1/2 binary64)
(sqrt (* im (neg (/ im re))))
(sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) #s(literal 0 binary64))))
(* im (neg (/ im re)))
(-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im re) #s(literal 0 binary64)))
im
(neg (/ im re))
(/.f64 im (-.f64 #s(literal 0 binary64) re))
(/ im re)
(/.f64 im re)
re
(* 1/2 (* (sqrt im) (sqrt (neg (/ im re)))))
(*.f64 (sqrt.f64 (/.f64 im (-.f64 #s(literal 0 binary64) re))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
1/2
#s(literal 1/2 binary64)
(* (sqrt im) (sqrt (neg (/ im re))))
(*.f64 (sqrt.f64 im) (sqrt.f64 (/.f64 im (-.f64 #s(literal 0 binary64) re))))
(sqrt im)
(sqrt.f64 im)
im
(sqrt (neg (/ im re)))
(sqrt.f64 (/.f64 im (-.f64 #s(literal 0 binary64) re)))
(neg (/ im re))
(/.f64 im (-.f64 #s(literal 0 binary64) re))
(/ im re)
(/.f64 im re)
re
(* 1/2 (/ (sqrt (* im im)) (sqrt (- 0 re))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (fabs.f64 im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
1/2
#s(literal 1/2 binary64)
(/ (sqrt (* im im)) (sqrt (- 0 re)))
(/.f64 (fabs.f64 im) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(sqrt (* im im))
(fabs.f64 im)
(* im im)
(fma.f64 im im #s(literal 0 binary64))
im
(sqrt (- 0 re))
(sqrt.f64 (-.f64 #s(literal 0 binary64) re))
(- 0 re)
(-.f64 #s(literal 0 binary64) re)
0
#s(literal 0 binary64)
re
(* 1/2 (* (sqrt (* im im)) (sqrt (neg (/ 1 re)))))
(*.f64 (sqrt.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 #s(literal 1/2 binary64) (fabs.f64 im)))
1/2
#s(literal 1/2 binary64)
(* (sqrt (* im im)) (sqrt (neg (/ 1 re))))
(*.f64 (fabs.f64 im) (sqrt.f64 (/.f64 #s(literal -1 binary64) re)))
(sqrt (* im im))
(fabs.f64 im)
(* im im)
(fma.f64 im im #s(literal 0 binary64))
im
(sqrt (neg (/ 1 re)))
(sqrt.f64 (/.f64 #s(literal -1 binary64) re))
(neg (/ 1 re))
(/.f64 #s(literal -1 binary64) re)
(/ 1 re)
(/.f64 #s(literal 1 binary64) re)
1
#s(literal 1 binary64)
re

localize159.0ms (1.6%)

Memory
-4.8MiB live, 113.4MiB allocated
Localize:

Found 19 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(neg.f64 (/.f64 #s(literal 1 binary64) re))
✓accuracy99.9%
(sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)))
✓accuracy99.9%
(*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re))))
✓accuracy81.2%
(sqrt.f64 (*.f64 im im))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
✓accuracy100.0%
(sqrt.f64 (-.f64 #s(literal 0 binary64) re))
✓accuracy99.8%
(/.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
✓accuracy81.2%
(sqrt.f64 (*.f64 im im))
✓accuracy100.0%
(sqrt.f64 im)
✓accuracy100.0%
(neg.f64 (/.f64 im re))
✓accuracy99.8%
(*.f64 (sqrt.f64 im) (sqrt.f64 (neg.f64 (/.f64 im re))))
✓accuracy92.0%
(sqrt.f64 (neg.f64 (/.f64 im re)))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re)))))
✓accuracy100.0%
(neg.f64 (/.f64 im re))
✓accuracy99.9%
(*.f64 im (neg.f64 (/.f64 im re)))
✓accuracy89.8%
(sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re))))
✓accuracy100.0%
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
✓accuracy100.0%
(*.f64 im #s(literal 2 binary64))
✓accuracy99.6%
(sqrt.f64 (*.f64 im #s(literal 2 binary64)))
Samples
47.0ms143×0invalid
23.0ms113×0valid
Compiler

Compiled 168 to 31 computations (81.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 31.0ms
ival-mult: 13.0ms (41.4% of total)
ival-sqrt: 10.0ms (31.8% of total)
ival-div: 4.0ms (12.7% of total)
ival-neg: 2.0ms (6.4% of total)
ival-sub: 1.0ms (3.2% 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.1%)

Memory
15.6MiB live, 15.6MiB allocated
Counts
20 → 384
Calls
Call 1
Inputs
#<alt (* (sqrt (* im 2)) 1/2)>
#<alt (sqrt (* im 2))>
#<alt (* im 2)>
#<alt (* 1/2 (sqrt (* im (neg (/ im re)))))>
#<alt (sqrt (* im (neg (/ im re))))>
#<alt (/ im re)>
#<alt (* im (neg (/ im re)))>
#<alt (* 1/2 (* (sqrt im) (sqrt (neg (/ im re)))))>
#<alt (* (sqrt im) (sqrt (neg (/ im re))))>
#<alt (sqrt im)>
#<alt (sqrt (neg (/ im re)))>
#<alt (sqrt (* im im))>
#<alt (* 1/2 (/ (sqrt (* im im)) (sqrt (- 0 re))))>
#<alt (/ (sqrt (* im im)) (sqrt (- 0 re)))>
#<alt (sqrt (- 0 re))>
#<alt (neg (/ 1 re))>
#<alt (* 1/2 (* (sqrt (* im im)) (sqrt (neg (/ 1 re)))))>
#<alt (* (sqrt (* im im)) (sqrt (neg (/ 1 re))))>
#<alt (neg (/ im re))>
#<alt (sqrt (neg (/ 1 re)))>
Outputs
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* 1/2 (* (sqrt im) (sqrt 2)))>
#<alt (* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 2 im)>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (/ im re)>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* -1 (/ (pow im 2) re))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (sqrt im)>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* -1 (* (sqrt (/ im re)) (sqrt -1)))>
#<alt (* -1 (* (sqrt (/ im re)) (sqrt -1)))>
#<alt (* -1 (* (sqrt (/ im re)) (sqrt -1)))>
#<alt (* -1 (* (sqrt (/ im re)) (sqrt -1)))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt (* (sqrt (/ im re)) (sqrt -1))>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt (* -1 im)>
#<alt (* -1 im)>
#<alt (* -1 im)>
#<alt (* -1 im)>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (/ im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (sqrt re) (sqrt -1))>
#<alt (* (sqrt re) (sqrt -1))>
#<alt (* (sqrt re) (sqrt -1))>
#<alt (* (sqrt re) (sqrt -1))>
#<alt (* (sqrt re) (sqrt -1))>
#<alt (* (sqrt re) (sqrt -1))>
#<alt (* (sqrt re) (sqrt -1))>
#<alt (* (sqrt re) (sqrt -1))>
#<alt (* -1 (* (sqrt re) (sqrt -1)))>
#<alt (* -1 (* (sqrt re) (sqrt -1)))>
#<alt (* -1 (* (sqrt re) (sqrt -1)))>
#<alt (* -1 (* (sqrt re) (sqrt -1)))>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (/ -1 re)>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* (* im (sqrt -1)) (sqrt (/ 1 re)))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* -1 (/ im re))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
#<alt (* (sqrt (/ 1 re)) (sqrt -1))>
Calls

96 calls:

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

rewrite298.0ms (3.1%)

Memory
-19.2MiB live, 422.1MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
2 160×accelerator-lowering-fma.f32
2 160×accelerator-lowering-fma.f64
2 052×*-lowering-*.f32
2 052×*-lowering-*.f64
1 034×log-div
Iterations

Useful iterations: 3 (0.0ms)

IterNodesCost
029108
110691
254091
3525579
0863879
Stop Event
1×iter limit
1×node limit
Counts
20 → 1 913
Calls
Call 1
Inputs
(* (sqrt (* im 2)) 1/2)
(sqrt (* im 2))
(* im 2)
(* 1/2 (sqrt (* im (neg (/ im re)))))
(sqrt (* im (neg (/ im re))))
(/ im re)
(* im (neg (/ im re)))
(* 1/2 (* (sqrt im) (sqrt (neg (/ im re)))))
(* (sqrt im) (sqrt (neg (/ im re))))
(sqrt im)
(sqrt (neg (/ im re)))
(sqrt (* im im))
(* 1/2 (/ (sqrt (* im im)) (sqrt (- 0 re))))
(/ (sqrt (* im im)) (sqrt (- 0 re)))
(sqrt (- 0 re))
(neg (/ 1 re))
(* 1/2 (* (sqrt (* im im)) (sqrt (neg (/ 1 re)))))
(* (sqrt (* im im)) (sqrt (neg (/ 1 re))))
(neg (/ im re))
(sqrt (neg (/ 1 re)))
Outputs
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 (sqrt.f64 im) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))))
(*.f64 (pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 im))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/4 binary64))) (pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im #s(literal 2 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 im #s(literal 2 binary64)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (*.f64 im #s(literal 2 binary64))))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(sqrt.f64 (*.f64 im #s(literal 2 binary64)))
(pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 im #s(literal 2 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (*.f64 im #s(literal 2 binary64)))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/4 binary64)) (pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 im #s(literal 2 binary64))
(*.f64 #s(literal 2 binary64) im)
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) #s(literal 2 binary64)))
(*.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 im)) (sqrt.f64 im))
(exp.f64 (*.f64 (log.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(neg.f64 (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64)))))
(/.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 re))
(/.f64 #s(literal -1/2 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (*.f64 im #s(literal -1/2 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (/.f64 #s(literal 1 binary64) im))
(/.f64 (neg.f64 (*.f64 im #s(literal -1/2 binary64))) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) im))) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))) (sqrt.f64 re))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 im #s(literal 1/2 binary64))) (sqrt.f64 re))
(/.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (/.f64 (*.f64 im #s(literal -1/2 binary64)) #s(literal -1 binary64)) (sqrt.f64 re))
(pow.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (sqrt.f64 im) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (sqrt.f64 (/.f64 im re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
(*.f64 #s(literal 1 binary64) (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 #s(literal -1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (*.f64 im #s(literal -1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 im #s(literal 1/2 binary64))))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))) (sqrt.f64 im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (-.f64 #s(literal 0 binary64) im))
(*.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))) (sqrt.f64 im))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im)))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 im)) (sqrt.f64 im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 re im))) (sqrt.f64 im))
(*.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) (sqrt.f64 re))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re))))
(exp.f64 (*.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 re (*.f64 im im))) #s(literal 0 binary64)) #s(literal -1 binary64)))
(exp.f64 (+.f64 (log.f64 im) (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 im) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 im re)))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 im re)) (*.f64 #s(literal 1/2 binary64) (log.f64 im))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)) (log.f64 im)))
(exp.f64 (-.f64 (log.f64 im) (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 re (*.f64 im im))) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re)))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 im (sqrt.f64 re)))
(-.f64 (/.f64 #s(literal 0 binary64) (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)))
(sqrt.f64 (/.f64 (*.f64 im im) re))
(neg.f64 (/.f64 im (sqrt.f64 re)))
(/.f64 im (sqrt.f64 re))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal -1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re))
(/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 #s(literal 1 binary64) im))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 re))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 im #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (sqrt.f64 re) im) #s(literal -1 binary64))
(pow.f64 (/.f64 re (*.f64 im im)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(pow.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64))
(pow.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (*.f64 im im) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 im im)) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (/.f64 (sqrt.f64 re) im) (/.f64 (sqrt.f64 re) im)) #s(literal -1/2 binary64))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im re) (sqrt.f64 re))
(*.f64 (sqrt.f64 im) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 im))
(*.f64 #s(literal 1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 #s(literal -1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 im)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) im))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) im)
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) im))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 (/.f64 im re))))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 #s(literal -1 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 im (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im)))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (*.f64 #s(literal 1 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (/.f64 im (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(+.f64 (/.f64 im re) #s(literal 0 binary64))
(+.f64 (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(+.f64 (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(+.f64 (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(+.f64 (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(+.f64 #s(literal 0 binary64) (/.f64 im re))
(+.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 0 binary64)) (/.f64 im re))
(+.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 im re))
(+.f64 (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 im re))
(+.f64 (*.f64 im #s(literal 0 binary64)) (/.f64 im re))
(+.f64 (*.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 im re))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (/.f64 im re))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im re))
(exp.f64 (log.f64 (/.f64 im re)))
(exp.f64 (*.f64 (log.f64 (/.f64 re im)) #s(literal -1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (/.f64 im re))) #s(literal 1/2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (/.f64 im re))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 im re)) (/.f64 im re))
(sqrt.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 im #s(literal 0 binary64) (/.f64 im re))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) im) (/.f64 im re))
(fma.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im re))
(fma.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 im re))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 0 binary64) (/.f64 im re))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 0 binary64))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) #s(literal 0 binary64))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64) (/.f64 im re))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re #s(literal 0 binary64))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64) (/.f64 im re))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) #s(literal 0 binary64))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re #s(literal 0 binary64))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(neg.f64 (/.f64 im re))
(/.f64 im re)
(/.f64 (/.f64 im re) #s(literal 1 binary64))
(/.f64 (/.f64 im re) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 re im))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) im))
(/.f64 #s(literal -1 binary64) (/.f64 re im))
(/.f64 (-.f64 #s(literal 0 binary64) im) re)
(/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 im re))
(/.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))))
(/.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) re)
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) re)
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) re) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) re) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 im (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 im (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 im re) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 im re) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)))
(/.f64 (*.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) re)
(/.f64 (/.f64 im #s(literal -1 binary64)) re)
(/.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64))) re)
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 im (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(pow.f64 (/.f64 im re) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 im re)) #s(literal 2 binary64))
(pow.f64 (/.f64 re im) #s(literal -1 binary64))
(pow.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 1/2 binary64))
(pow.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) #s(literal -1 binary64))
(*.f64 im (/.f64 #s(literal 1 binary64) re))
(*.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))))
(*.f64 (/.f64 im re) #s(literal 1 binary64))
(*.f64 (/.f64 im re) #s(literal -1 binary64))
(*.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re))
(*.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)))
(*.f64 #s(literal 1 binary64) (/.f64 im re))
(*.f64 (/.f64 #s(literal 1 binary64) re) im)
(*.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im))
(*.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 im re))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re))
(*.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(*.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)))
(*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re)
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re))
(*.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re))
(*.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)))
(*.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)))
(*.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re)
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im))
(*.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re)
(+.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(+.f64 (/.f64 (*.f64 im im) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(+.f64 (/.f64 (*.f64 im im) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(+.f64 (/.f64 (*.f64 im im) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(+.f64 (/.f64 (*.f64 im im) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(+.f64 (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (/.f64 (*.f64 im im) re))
(+.f64 (*.f64 im #s(literal 0 binary64)) (/.f64 (*.f64 im im) re))
(+.f64 (*.f64 (*.f64 im im) #s(literal 0 binary64)) (/.f64 (*.f64 im im) re))
(+.f64 (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 (*.f64 im im) re))
(+.f64 (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 (*.f64 im im) re))
(+.f64 (*.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 (*.f64 im im) re))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (/.f64 (*.f64 im im) re))
(exp.f64 (log.f64 (/.f64 (*.f64 im im) re)))
(exp.f64 (*.f64 (log.f64 (/.f64 re (*.f64 im im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(fma.f64 im (/.f64 im re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 im (/.f64 im re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 im (/.f64 im re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 im (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 im #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(fma.f64 re (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 re (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 re (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 re (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) im (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im re) im (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) im (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) im (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) (-.f64 #s(literal 0 binary64) im) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im re) (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) (-.f64 #s(literal 0 binary64) im) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) (-.f64 #s(literal 0 binary64) im) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) (/.f64 im #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im re) (/.f64 im #s(literal 1 binary64)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) (/.f64 im #s(literal 1 binary64)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) (/.f64 im #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im re) (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 im re)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 im re)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 im re)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 im re)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 im re)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 im re)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 im re)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 im re)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) (/.f64 re im)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) (/.f64 re im)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) (/.f64 re im)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) (/.f64 re im)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 im im) #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 #s(literal 0 binary64) (*.f64 im im) (/.f64 (*.f64 im im) re))
(fma.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 (*.f64 im im) re))
(fma.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (*.f64 im im) re))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1 binary64) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1 binary64) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal -1 binary64) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal -1 binary64) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) re (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) re (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) re (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) re (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re (*.f64 im im)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re (*.f64 im im)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re (*.f64 im im)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 im re)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 im re)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 im re)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 im re)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64) (/.f64 (*.f64 im im) re))
(fma.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 im re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 im re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 im re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) im)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) im)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) im)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) im)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 im re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 im re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 im re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 im re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 im re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 im re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (*.f64 im im) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 (*.f64 im im) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 im re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (/.f64 im re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (*.f64 im im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (*.f64 (*.f64 im im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (*.f64 im im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (*.f64 (*.f64 im im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(neg.f64 (/.f64 (*.f64 im im) re))
(/.f64 im (/.f64 re im))
(/.f64 (/.f64 im re) (/.f64 #s(literal 1 binary64) im))
(/.f64 (*.f64 im im) re)
(/.f64 #s(literal 1 binary64) (/.f64 re (*.f64 im im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 re (*.f64 im im)) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 re (*.f64 im im)))
(/.f64 (/.f64 (*.f64 im im) re) #s(literal 1 binary64))
(/.f64 (/.f64 (*.f64 im im) re) #s(literal -1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 re im))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) re)
(/.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re))
(/.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 re im))
(/.f64 (*.f64 (*.f64 im im) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 (*.f64 im im) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 (*.f64 im im) re) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 (*.f64 im im) re) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)))
(/.f64 (*.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) re)
(/.f64 (/.f64 (*.f64 im im) #s(literal -1 binary64)) re)
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re) (*.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re))) (/.f64 (*.f64 im im) re))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) re)
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal -1 binary64)) re)
(/.f64 (*.f64 im (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(/.f64 (*.f64 im (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (/.f64 im re))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 im im))) re)
(/.f64 (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64))) re)
(/.f64 (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) im) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(/.f64 (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) im) (/.f64 im re))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))))
(/.f64 (*.f64 (*.f64 im im) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal -1 binary64)) re)
(pow.f64 (/.f64 re (*.f64 im im)) #s(literal -1 binary64))
(pow.f64 (/.f64 im (sqrt.f64 re)) #s(literal 2 binary64))
(pow.f64 (/.f64 (/.f64 re (*.f64 im im)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (*.f64 (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64))
(*.f64 im (/.f64 im re))
(*.f64 re (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(*.f64 (/.f64 im re) im)
(*.f64 (/.f64 im re) (-.f64 #s(literal 0 binary64) im))
(*.f64 (/.f64 im re) (/.f64 im #s(literal 1 binary64)))
(*.f64 (/.f64 im re) (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 im re)))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 im re)))
(*.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) (/.f64 re im)))
(*.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) re))
(*.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im im))
(*.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) (*.f64 im im)))
(*.f64 #s(literal -1 binary64) (/.f64 (*.f64 im im) re))
(*.f64 (/.f64 (*.f64 im im) re) #s(literal 1 binary64))
(*.f64 (/.f64 (*.f64 im im) re) #s(literal -1 binary64))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im re))
(*.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 im (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)))
(*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) re)
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re (*.f64 im im)))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 im re)))
(*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im))
(*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) (*.f64 im im)))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 im re))
(*.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 im re))
(*.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 im re))
(*.f64 (/.f64 (*.f64 im im) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 (/.f64 im re) (sqrt.f64 im)) (sqrt.f64 im))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re)
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) re)
(*.f64 (*.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re)
(*.f64 (*.f64 (*.f64 im im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (*.f64 im im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(exp.f64 (*.f64 (log.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(neg.f64 (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64)))))
(/.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 re))
(/.f64 #s(literal -1/2 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (*.f64 im #s(literal -1/2 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (/.f64 #s(literal 1 binary64) im))
(/.f64 (neg.f64 (*.f64 im #s(literal -1/2 binary64))) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) im))) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))) (sqrt.f64 re))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 im #s(literal 1/2 binary64))) (sqrt.f64 re))
(/.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (/.f64 (*.f64 im #s(literal -1/2 binary64)) #s(literal -1 binary64)) (sqrt.f64 re))
(pow.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (sqrt.f64 im) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (sqrt.f64 (/.f64 im re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
(*.f64 #s(literal 1 binary64) (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 #s(literal -1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (*.f64 im #s(literal -1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 im #s(literal 1/2 binary64))))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))) (sqrt.f64 im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (-.f64 #s(literal 0 binary64) im))
(*.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))) (sqrt.f64 im))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im)))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 im)) (sqrt.f64 im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 re im))) (sqrt.f64 im))
(*.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) (sqrt.f64 re))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re))))
(exp.f64 (*.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 re (*.f64 im im))) #s(literal 0 binary64)) #s(literal -1 binary64)))
(exp.f64 (+.f64 (log.f64 im) (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 im) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 im re)))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 im re)) (*.f64 #s(literal 1/2 binary64) (log.f64 im))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)) (log.f64 im)))
(exp.f64 (-.f64 (log.f64 im) (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 re (*.f64 im im))) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re)))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 im (sqrt.f64 re)))
(-.f64 (/.f64 #s(literal 0 binary64) (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)))
(sqrt.f64 (/.f64 (*.f64 im im) re))
(neg.f64 (/.f64 im (sqrt.f64 re)))
(/.f64 im (sqrt.f64 re))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal -1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re))
(/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 #s(literal 1 binary64) im))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 re))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 im #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (sqrt.f64 re) im) #s(literal -1 binary64))
(pow.f64 (/.f64 re (*.f64 im im)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(pow.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64))
(pow.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (*.f64 im im) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 im im)) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (/.f64 (sqrt.f64 re) im) (/.f64 (sqrt.f64 re) im)) #s(literal -1/2 binary64))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im re) (sqrt.f64 re))
(*.f64 (sqrt.f64 im) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 im))
(*.f64 #s(literal 1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 #s(literal -1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 im)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) im))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) im)
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) im))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 (/.f64 im re))))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 #s(literal -1 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 im (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im)))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (*.f64 #s(literal 1 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (/.f64 im (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(exp.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (log.f64 im) #s(literal 0 binary64)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (sqrt.f64 (sqrt.f64 im))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (log.f64 im) #s(literal 0 binary64)) #s(literal 1/4 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(fabs.f64 (sqrt.f64 im))
(sqrt.f64 im)
(pow.f64 im #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 im) #s(literal 1 binary64))
(pow.f64 (*.f64 im im) #s(literal 1/4 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 1/8 binary64))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 (sqrt.f64 im)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 im re))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)) (*.f64 #s(literal 1/2 binary64) (log.f64 im))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 im) (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)))))
(exp.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64))))
(exp.f64 (*.f64 (log.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 re im)) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (/.f64 im re))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (/.f64 im re)) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (/.f64 re im)) #s(literal -1 binary64)) #s(literal 1/2 binary64)))
(sqrt.f64 (/.f64 im re))
(/.f64 (/.f64 im re) (sqrt.f64 (/.f64 im re)))
(/.f64 (sqrt.f64 im) (sqrt.f64 re))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 re im)))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) (sqrt.f64 (-.f64 #s(literal 0 binary64) im))))
(/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (sqrt.f64 re))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 re))
(/.f64 (sqrt.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))) (/.f64 im re))
(/.f64 (neg.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im))) (sqrt.f64 re))
(/.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (*.f64 (sqrt.f64 im) #s(literal -1 binary64)) (sqrt.f64 re))
(pow.f64 (/.f64 im re) #s(literal 1/2 binary64))
(pow.f64 (/.f64 re im) #s(literal -1/2 binary64))
(pow.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) #s(literal 2 binary64))
(pow.f64 (sqrt.f64 (/.f64 re im)) #s(literal -1 binary64))
(pow.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal -1/4 binary64))
(pow.f64 (/.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64))
(pow.f64 (/.f64 (sqrt.f64 re) (sqrt.f64 (-.f64 #s(literal 0 binary64) im))) #s(literal -1 binary64))
(*.f64 (sqrt.f64 im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (/.f64 im re)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 im))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (/.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 re)))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (sqrt.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) (sqrt.f64 re))
(*.f64 (/.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (sqrt.f64 im) re) (sqrt.f64 re))
(*.f64 (/.f64 (sqrt.f64 im) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
im
(exp.f64 (log.f64 im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 1 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (log.f64 im) #s(literal 0 binary64)) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(fabs.f64 im)
(fabs.f64 (-.f64 #s(literal 0 binary64) im))
(fabs.f64 (-.f64 im #s(literal 0 binary64)))
(-.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) im))
(sqrt.f64 (*.f64 im im))
(sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)))
(neg.f64 (-.f64 #s(literal 0 binary64) im))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) im))
(pow.f64 im #s(literal 1 binary64))
(pow.f64 (sqrt.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1/2 binary64))
(pow.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) im) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 im)) #s(literal 4 binary64))
(pow.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 1/4 binary64))
(*.f64 im #s(literal 1 binary64))
(*.f64 (sqrt.f64 im) (sqrt.f64 im))
(*.f64 (sqrt.f64 im) (sqrt.f64 (-.f64 #s(literal 0 binary64) im)))
(*.f64 (sqrt.f64 im) (fabs.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im))))
(*.f64 (sqrt.f64 im) (neg.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im))))
(*.f64 #s(literal 1 binary64) im)
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) im))
(*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 im)))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 im))
(*.f64 (fabs.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im))) (sqrt.f64 im))
(*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im))) (sqrt.f64 im))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 im))) (sqrt.f64 im))
(exp.f64 (*.f64 (log.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(neg.f64 (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64)))))
(/.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 re))
(/.f64 #s(literal -1/2 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (*.f64 im #s(literal -1/2 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (/.f64 #s(literal 1 binary64) im))
(/.f64 (neg.f64 (*.f64 im #s(literal -1/2 binary64))) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) im))) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))) (sqrt.f64 re))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 im #s(literal 1/2 binary64))) (sqrt.f64 re))
(/.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (/.f64 (*.f64 im #s(literal -1/2 binary64)) #s(literal -1 binary64)) (sqrt.f64 re))
(pow.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (sqrt.f64 im) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (sqrt.f64 (/.f64 im re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
(*.f64 #s(literal 1 binary64) (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 #s(literal -1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (*.f64 im #s(literal -1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 im #s(literal 1/2 binary64))))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))) (sqrt.f64 im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (-.f64 #s(literal 0 binary64) im))
(*.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))) (sqrt.f64 im))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im)))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 im)) (sqrt.f64 im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 re im))) (sqrt.f64 im))
(*.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) (sqrt.f64 re))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re))))
(exp.f64 (*.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 re (*.f64 im im))) #s(literal 0 binary64)) #s(literal -1 binary64)))
(exp.f64 (+.f64 (log.f64 im) (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 im) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 im re)))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 im re)) (*.f64 #s(literal 1/2 binary64) (log.f64 im))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)) (log.f64 im)))
(exp.f64 (-.f64 (log.f64 im) (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 re (*.f64 im im))) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re)))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 im (sqrt.f64 re)))
(-.f64 (/.f64 #s(literal 0 binary64) (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)))
(sqrt.f64 (/.f64 (*.f64 im im) re))
(neg.f64 (/.f64 im (sqrt.f64 re)))
(/.f64 im (sqrt.f64 re))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal -1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re))
(/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 #s(literal 1 binary64) im))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 re))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 im #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (sqrt.f64 re) im) #s(literal -1 binary64))
(pow.f64 (/.f64 re (*.f64 im im)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(pow.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64))
(pow.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (*.f64 im im) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 im im)) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (/.f64 (sqrt.f64 re) im) (/.f64 (sqrt.f64 re) im)) #s(literal -1/2 binary64))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im re) (sqrt.f64 re))
(*.f64 (sqrt.f64 im) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 im))
(*.f64 #s(literal 1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 #s(literal -1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 im)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) im))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) im)
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) im))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 (/.f64 im re))))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 #s(literal -1 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 im (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im)))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (*.f64 #s(literal 1 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (/.f64 im (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(+.f64 #s(literal 0 binary64) (sqrt.f64 re))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64)))
(exp.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (log.f64 re) #s(literal 0 binary64)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 re)) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(-.f64 #s(literal 0 binary64) (sqrt.f64 re))
(sqrt.f64 re)
(neg.f64 (sqrt.f64 re))
(/.f64 re (sqrt.f64 re))
(/.f64 (sqrt.f64 re) #s(literal 1 binary64))
(/.f64 (sqrt.f64 re) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(/.f64 #s(literal 1 binary64) (/.f64 re (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) re))
(/.f64 (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re)
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (+.f64 #s(literal 0 binary64) (+.f64 re (*.f64 #s(literal 0 binary64) (sqrt.f64 re)))))
(/.f64 (*.f64 #s(literal -1 binary64) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(pow.f64 re #s(literal 1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1/2 binary64))
(pow.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 2 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64))
(pow.f64 (/.f64 re (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 re) re) #s(literal -1 binary64))
(*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 re) #s(literal 1 binary64))
(*.f64 (sqrt.f64 re) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (sqrt.f64 re))
(*.f64 #s(literal -1 binary64) (sqrt.f64 re))
(*.f64 (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (neg.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (/.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 1 binary64)))
(*.f64 (neg.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (*.f64 #s(literal -1 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(+.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) re))
(+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(+.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(+.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(+.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) re))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) re))
(exp.f64 (-.f64 #s(literal 0 binary64) (log.f64 re)))
(exp.f64 (*.f64 (fma.f64 #s(literal -2 binary64) (log.f64 re) #s(literal 0 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (log.f64 re) #s(literal 0 binary64)) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 re) #s(literal -1/2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re))) #s(literal 2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) re))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))))
(fma.f64 re (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 re (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 re (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 re (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 re (/.f64 re (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 re (/.f64 re (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 re (/.f64 re (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 re (/.f64 re (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re))
(fma.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) re #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) re (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) re (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) re (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) re))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) re))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(neg.f64 (/.f64 #s(literal 1 binary64) re))
(/.f64 re (fma.f64 re re #s(literal 0 binary64)))
(/.f64 re (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) re)
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(/.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) re)
(/.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re))
(/.f64 (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 #s(literal -1 binary64) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 #s(literal -1 binary64) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64))) re)
(pow.f64 re #s(literal -1 binary64))
(pow.f64 (sqrt.f64 re) #s(literal -2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64))
(pow.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) #s(literal 4 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 1/4 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) #s(literal -1 binary64))
(*.f64 re (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))))
(*.f64 re (/.f64 re (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re))
(*.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) re)
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(*.f64 (/.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)))
(*.f64 (/.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(neg.f64 (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64)))))
(/.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 re))
(/.f64 #s(literal -1/2 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (*.f64 im #s(literal -1/2 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (/.f64 #s(literal 1 binary64) im))
(/.f64 (neg.f64 (*.f64 im #s(literal -1/2 binary64))) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) im))) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))) (sqrt.f64 re))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 im #s(literal 1/2 binary64))) (sqrt.f64 re))
(/.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (/.f64 (*.f64 im #s(literal -1/2 binary64)) #s(literal -1 binary64)) (sqrt.f64 re))
(pow.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (sqrt.f64 re) (*.f64 im #s(literal 1/2 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (sqrt.f64 im) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (sqrt.f64 (/.f64 im re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
(*.f64 #s(literal 1 binary64) (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 #s(literal -1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (*.f64 im #s(literal -1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 im #s(literal 1/2 binary64))))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))) (sqrt.f64 im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (-.f64 #s(literal 0 binary64) im))
(*.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))) (sqrt.f64 im))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im)))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (*.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 im re))) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 im)) (sqrt.f64 im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 re im))) (sqrt.f64 im))
(*.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) (sqrt.f64 re))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re))))
(exp.f64 (*.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 re (*.f64 im im))) #s(literal 0 binary64)) #s(literal -1 binary64)))
(exp.f64 (+.f64 (log.f64 im) (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 im) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 im re)))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 im re)) (*.f64 #s(literal 1/2 binary64) (log.f64 im))))
(exp.f64 (fma.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re)) (log.f64 im)))
(exp.f64 (-.f64 (log.f64 im) (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 re (*.f64 im im))) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re)))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 im (sqrt.f64 re)))
(-.f64 (/.f64 #s(literal 0 binary64) (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)))
(sqrt.f64 (/.f64 (*.f64 im im) re))
(neg.f64 (/.f64 im (sqrt.f64 re)))
(/.f64 im (sqrt.f64 re))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal -1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re))
(/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 #s(literal 1 binary64) im))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 re))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 im #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (sqrt.f64 re) im) #s(literal -1 binary64))
(pow.f64 (/.f64 re (*.f64 im im)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(pow.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64))
(pow.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (*.f64 im im) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 im im)) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (*.f64 (/.f64 (sqrt.f64 re) im) (/.f64 (sqrt.f64 re) im)) #s(literal -1/2 binary64))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im re) (sqrt.f64 re))
(*.f64 (sqrt.f64 im) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 im))
(*.f64 #s(literal 1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 #s(literal -1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (*.f64 (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 im)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) im))
(*.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) im)
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) im))
(*.f64 (sqrt.f64 (sqrt.f64 im)) (*.f64 (sqrt.f64 (sqrt.f64 im)) (sqrt.f64 (/.f64 im re))))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 im im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 #s(literal -1 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (/.f64 im (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(*.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 im (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im)))) (*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 im))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (sqrt.f64 im))) (sqrt.f64 (sqrt.f64 im)))
(*.f64 (*.f64 #s(literal 1 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (*.f64 (sqrt.f64 im) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (/.f64 im (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(+.f64 (/.f64 im re) #s(literal 0 binary64))
(+.f64 (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(+.f64 (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(+.f64 (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(+.f64 (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(+.f64 #s(literal 0 binary64) (/.f64 im re))
(+.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 0 binary64)) (/.f64 im re))
(+.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 im re))
(+.f64 (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 im re))
(+.f64 (*.f64 im #s(literal 0 binary64)) (/.f64 im re))
(+.f64 (*.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 im re))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (/.f64 im re))
(+.f64 (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) (/.f64 im re))
(exp.f64 (log.f64 (/.f64 im re)))
(exp.f64 (*.f64 (log.f64 (/.f64 re im)) #s(literal -1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (/.f64 im re))) #s(literal 1/2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (/.f64 im re))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 im re)) (/.f64 im re))
(sqrt.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 im #s(literal 0 binary64) (/.f64 im re))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 im (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) #s(literal 1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im re) #s(literal -1 binary64) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) im) (/.f64 im re))
(fma.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im re))
(fma.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 im re))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 #s(literal 1 binary64) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) im (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 #s(literal -1 binary64) (/.f64 im re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 0 binary64) (/.f64 im re))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 0 binary64))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) #s(literal 0 binary64))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) #s(literal 0 binary64))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64) (/.f64 im re))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re #s(literal 0 binary64))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64) (/.f64 im re))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) #s(literal 0 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) #s(literal 0 binary64))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im) (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re #s(literal 0 binary64))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))))
(fma.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re (*.f64 #s(literal 0 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))))
(neg.f64 (/.f64 im re))
(/.f64 im re)
(/.f64 (/.f64 im re) #s(literal 1 binary64))
(/.f64 (/.f64 im re) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 re im))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) im))
(/.f64 #s(literal -1 binary64) (/.f64 re im))
(/.f64 (-.f64 #s(literal 0 binary64) im) re)
(/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))
(/.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 im re))
(/.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))))
(/.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) re)
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) re)
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) re) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) re) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 im (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 im (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 re (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 im re) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 im re) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)))
(/.f64 (*.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) re)
(/.f64 (/.f64 im #s(literal -1 binary64)) re)
(/.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 (fma.f64 re re #s(literal 0 binary64)) (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(/.f64 (*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64))) re)
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 im (fma.f64 re re #s(literal 0 binary64))) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))
(pow.f64 (/.f64 im re) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 im re)) #s(literal 2 binary64))
(pow.f64 (/.f64 re im) #s(literal -1 binary64))
(pow.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) #s(literal 1/2 binary64))
(pow.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) #s(literal -1 binary64))
(*.f64 im (/.f64 #s(literal 1 binary64) re))
(*.f64 re (/.f64 im (fma.f64 re re #s(literal 0 binary64))))
(*.f64 (/.f64 im re) #s(literal 1 binary64))
(*.f64 (/.f64 im re) #s(literal -1 binary64))
(*.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) re))
(*.f64 (sqrt.f64 im) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 im) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 (/.f64 im re)))
(*.f64 #s(literal 1 binary64) (/.f64 im re))
(*.f64 (/.f64 #s(literal 1 binary64) re) im)
(*.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) im))
(*.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 im #s(literal 1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 im re))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re))
(*.f64 (fma.f64 re re #s(literal 0 binary64)) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))))
(*.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (*.f64 (/.f64 im re) (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)))
(*.f64 (fma.f64 im (/.f64 im (fma.f64 re re #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 re im))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (*.f64 re im))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 (sqrt.f64 im) re))
(*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (*.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 im (fma.f64 re re #s(literal 0 binary64))) re)
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (*.f64 (fma.f64 re re #s(literal 0 binary64)) im))
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re))
(*.f64 (/.f64 (sqrt.f64 im) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re))
(*.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)))
(*.f64 (/.f64 (sqrt.f64 im) re) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal 1 binary64)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) re) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)))
(*.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (sqrt.f64 im) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (sqrt.f64 im) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) #s(literal -1 binary64)) (/.f64 (sqrt.f64 im) re))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64)))))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 im)) (fma.f64 re re #s(literal 0 binary64))) (/.f64 (sqrt.f64 im) (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(*.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (fma.f64 re re #s(literal 0 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (/.f64 im (fma.f64 re re #s(literal 0 binary64)))) re)
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 im)) (sqrt.f64 im))
(*.f64 (*.f64 (/.f64 im (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64))) re) re)
(exp.f64 (*.f64 (log.f64 re) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64)) #s(literal -1 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (log.f64 re))))
(exp.f64 (neg.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64))))
(exp.f64 (*.f64 (fma.f64 #s(literal -2 binary64) (log.f64 re) #s(literal 0 binary64)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 re)) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(fabs.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 re))
(/.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(/.f64 #s(literal -1 binary64) (sqrt.f64 re))
(/.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) (/.f64 #s(literal 1 binary64) re))
(pow.f64 re #s(literal -1/2 binary64))
(pow.f64 (sqrt.f64 re) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64))
(pow.f64 (fma.f64 re re #s(literal 0 binary64)) #s(literal -1/4 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 0 binary64))) #s(literal 1/4 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) #s(literal 2 binary64))
(pow.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) #s(literal -2 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 #s(literal 1 binary64) re) (sqrt.f64 re))
(*.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64))
(*.f64 (pow.f64 #s(literal -1 binary64) #s(literal -1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re (fma.f64 re re #s(literal 0 binary64)) #s(literal 0 binary64)))) re)

simplify426.0ms (4.4%)

Memory
13.5MiB live, 373.3MiB allocated
Algorithm
1×egg-herbie
Rules
3 000×*-lowering-*.f32
3 000×*-lowering-*.f64
2 824×accelerator-lowering-fma.f32
2 824×accelerator-lowering-fma.f64
2 126×unsub-neg
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0482852
11182852
23092852
35832852
410882852
518582852
632312852
743152852
849772852
952182852
1054552852
1164592852
1268572852
1369682852
1469732852
1569732852
1669752852
1770632852
1871622852
1972382852
2072722852
2172802852
2272802852
2373682852
2474982852
2574982852
2679852852
081292852
Stop Event
1×iter limit
1×node limit
Counts
384 → 384
Calls
Call 1
Inputs
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* (sqrt im) (sqrt 2))
(* (sqrt im) (sqrt 2))
(* (sqrt im) (sqrt 2))
(* (sqrt im) (sqrt 2))
(* (sqrt im) (sqrt 2))
(* (sqrt im) (sqrt 2))
(* (sqrt im) (sqrt 2))
(* (sqrt im) (sqrt 2))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 2 im)
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(/ im re)
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* -1 (/ (pow im 2) re))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(sqrt im)
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* -1 (* (sqrt (/ im re)) (sqrt -1)))
(* -1 (* (sqrt (/ im re)) (sqrt -1)))
(* -1 (* (sqrt (/ im re)) (sqrt -1)))
(* -1 (* (sqrt (/ im re)) (sqrt -1)))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
(* (sqrt (/ im re)) (sqrt -1))
im
im
im
im
im
im
im
im
(* -1 im)
(* -1 im)
(* -1 im)
(* -1 im)
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (sqrt re) (sqrt -1))
(* (sqrt re) (sqrt -1))
(* (sqrt re) (sqrt -1))
(* (sqrt re) (sqrt -1))
(* (sqrt re) (sqrt -1))
(* (sqrt re) (sqrt -1))
(* (sqrt re) (sqrt -1))
(* (sqrt re) (sqrt -1))
(* -1 (* (sqrt re) (sqrt -1)))
(* -1 (* (sqrt re) (sqrt -1)))
(* -1 (* (sqrt re) (sqrt -1)))
(* -1 (* (sqrt re) (sqrt -1)))
(/ -1 re)
(/ -1 re)
(/ -1 re)
(/ -1 re)
(/ -1 re)
(/ -1 re)
(/ -1 re)
(/ -1 re)
(/ -1 re)
(/ -1 re)
(/ -1 re)
(/ -1 re)
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* -1 (/ im re))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
(* (sqrt (/ 1 re)) (sqrt -1))
Outputs
(* 1/2 (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(fma.f64 (fma.f64 (sqrt.f64 #s(literal -2 binary64)) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (fma.f64 (sqrt.f64 im) #s(literal -1/2 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(fma.f64 (fma.f64 (sqrt.f64 #s(literal -2 binary64)) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (fma.f64 (sqrt.f64 im) #s(literal -1/2 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(fma.f64 (fma.f64 (sqrt.f64 #s(literal -2 binary64)) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (fma.f64 (sqrt.f64 im) #s(literal -1/2 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(fma.f64 (fma.f64 (sqrt.f64 #s(literal -2 binary64)) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (fma.f64 (sqrt.f64 im) #s(literal -1/2 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))
(* (sqrt im) (sqrt 2))
(fma.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)) #s(literal 0 binary64))
(* (sqrt im) (sqrt 2))
(fma.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)) #s(literal 0 binary64))
(* (sqrt im) (sqrt 2))
(fma.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)) #s(literal 0 binary64))
(* (sqrt im) (sqrt 2))
(fma.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)) #s(literal 0 binary64))
(* (sqrt im) (sqrt 2))
(fma.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)) #s(literal 0 binary64))
(* (sqrt im) (sqrt 2))
(fma.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)) #s(literal 0 binary64))
(* (sqrt im) (sqrt 2))
(fma.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)) #s(literal 0 binary64))
(* (sqrt im) (sqrt 2))
(fma.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64)) #s(literal 0 binary64))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(fma.f64 (sqrt.f64 im) (-.f64 #s(literal 0 binary64) (fma.f64 (sqrt.f64 #s(literal -2 binary64)) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(fma.f64 (sqrt.f64 im) (-.f64 #s(literal 0 binary64) (fma.f64 (sqrt.f64 #s(literal -2 binary64)) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(fma.f64 (sqrt.f64 im) (-.f64 #s(literal 0 binary64) (fma.f64 (sqrt.f64 #s(literal -2 binary64)) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))
(fma.f64 (sqrt.f64 im) (-.f64 #s(literal 0 binary64) (fma.f64 (sqrt.f64 #s(literal -2 binary64)) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 im)
(fma.f64 im #s(literal 2 binary64) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(/ im re)
(/.f64 im re)
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* -1 (/ (pow im 2) re))
(fma.f64 im (-.f64 #s(literal 0 binary64) (/.f64 im re)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(sqrt im)
(sqrt.f64 im)
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(sqrt.f64 im)
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(sqrt.f64 im)
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(sqrt.f64 im)
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(sqrt.f64 im)
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* -1 (* (sqrt (/ im re)) (sqrt -1)))
(fma.f64 (sqrt.f64 (/.f64 im re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* -1 (* (sqrt (/ im re)) (sqrt -1)))
(fma.f64 (sqrt.f64 (/.f64 im re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* -1 (* (sqrt (/ im re)) (sqrt -1)))
(fma.f64 (sqrt.f64 (/.f64 im re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* -1 (* (sqrt (/ im re)) (sqrt -1)))
(fma.f64 (sqrt.f64 (/.f64 im re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
(* (sqrt (/ im re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 im re)) #s(literal 0 binary64))
im
im
im
im
im
im
im
im
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 im #s(literal -1/2 binary64) #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 im #s(literal -1/2 binary64) #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 im #s(literal -1/2 binary64) #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* -1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 im #s(literal -1/2 binary64) #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) #s(literal 0 binary64))
(* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) #s(literal 0 binary64))
(* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) #s(literal 0 binary64))
(* -1 (* (/ im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (/ im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt re) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 re) #s(literal 0 binary64))
(* (sqrt re) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 re) #s(literal 0 binary64))
(* (sqrt re) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 re) #s(literal 0 binary64))
(* (sqrt re) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 re) #s(literal 0 binary64))
(* (sqrt re) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 re) #s(literal 0 binary64))
(* (sqrt re) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 re) #s(literal 0 binary64))
(* (sqrt re) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 re) #s(literal 0 binary64))
(* (sqrt re) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 re) #s(literal 0 binary64))
(* -1 (* (sqrt re) (sqrt -1)))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)) #s(literal 0 binary64))
(* -1 (* (sqrt re) (sqrt -1)))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)) #s(literal 0 binary64))
(* -1 (* (sqrt re) (sqrt -1)))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)) #s(literal 0 binary64))
(* -1 (* (sqrt re) (sqrt -1)))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)) #s(literal 0 binary64))
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(/ -1 re)
(/.f64 #s(literal -1 binary64) re)
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* -1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* -1 (* (* im (sqrt -1)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64))) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (* im (sqrt -1)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 im (sqrt.f64 #s(literal -1 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* -1 (/ im re))
(-.f64 #s(literal 0 binary64) (/.f64 im re))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt (/ 1 re)) (sqrt -1))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))

eval439.0ms (4.5%)

Memory
49.3MiB live, 615.0MiB allocated
Compiler

Compiled 60 249 to 8 119 computations (86.5% saved)

prune686.0ms (7.1%)

Memory
-39.9MiB live, 751.9MiB allocated
Pruning

15 alts after pruning (4 fresh and 11 done)

PrunedKeptTotal
New3 17223 174
Fresh022
Picked235
Done189
Total3 175153 190
Accuracy
100.0%
Counts
3 190 → 15
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓54.9%
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
✓51.7%
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
✓51.8%
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
22.7%
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
✓21.5%
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (neg.f64 (/.f64 im re)))))
22.7%
(*.f64 #s(literal 1/2 binary64) (*.f64 im (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)))))
✓52.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))))
✓29.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
✓17.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re)))))
39.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) re))))
41.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))) re))))
✓41.1%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
✓54.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
✓29.4%
(sqrt.f64 re)
✓5.4%
#s(literal 0 binary64)
Compiler

Compiled 413 to 227 computations (45% saved)

regimes112.0ms (1.2%)

Memory
-19.3MiB live, 100.4MiB allocated
Counts
22 → 4
Calls
Call 1
Inputs
#s(literal 0 binary64)
(sqrt.f64 re)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re))))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re)))))
(*.f64 #s(literal 1/2 binary64) (*.f64 im (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (neg.f64 (/.f64 im re)))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (*.f64 im im)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (sqrt.f64 (fma.f64 re re (*.f64 im im)))) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) re))))
Outputs
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))) re))))
(sqrt.f64 re)
Calls

7 calls:

39.0ms
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
36.0ms
(*.f64 im im)
9.0ms
re
7.0ms
im
7.0ms
(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
Results
AccuracySegmentsBranch
83.5%4re
66.8%4im
73.4%3(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
73.4%3(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
74.0%3(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
74.0%3(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
66.7%4(*.f64 im im)
Compiler

Compiled 69 to 45 computations (34.8% saved)

regimes7.0ms (0.1%)

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

1 calls:

6.0ms
re
Results
AccuracySegmentsBranch
83.5%4re
Compiler

Compiled 3 to 2 computations (33.3% saved)

regimes6.0ms (0.1%)

Memory
11.5MiB live, 11.5MiB allocated
Counts
15 → 3
Calls
Call 1
Inputs
#s(literal 0 binary64)
(sqrt.f64 re)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re))))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re)))))
(*.f64 #s(literal 1/2 binary64) (*.f64 im (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 im im) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 im re) (*.f64 re #s(literal 4 binary64)))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64)))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 im) (sqrt.f64 (neg.f64 (/.f64 im re)))))
Outputs
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
(sqrt.f64 re)
Calls

1 calls:

5.0ms
re
Results
AccuracySegmentsBranch
79.9%3re
Compiler

Compiled 3 to 2 computations (33.3% saved)

regimes4.0ms (0%)

Memory
9.7MiB live, 9.7MiB allocated
Counts
10 → 3
Calls
Call 1
Inputs
#s(literal 0 binary64)
(sqrt.f64 re)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re))))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im (neg.f64 (/.f64 im re)))))
(*.f64 #s(literal 1/2 binary64) (*.f64 im (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) re)))))
Outputs
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
(sqrt.f64 re)
Calls

1 calls:

4.0ms
re
Results
AccuracySegmentsBranch
79.7%3re
Compiler

Compiled 3 to 2 computations (33.3% saved)

regimes16.0ms (0.2%)

Memory
-9.1MiB live, 30.4MiB allocated
Counts
6 → 2
Calls
Call 1
Inputs
#s(literal 0 binary64)
(sqrt.f64 re)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (-.f64 #s(literal 0 binary64) re) re))))
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(sqrt.f64 re)
Calls

5 calls:

5.0ms
re
3.0ms
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
3.0ms
(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
3.0ms
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
2.0ms
(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
Results
AccuracySegmentsBranch
54.8%1(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
54.8%1(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
54.8%1(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
54.8%1(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
67.8%2re
Compiler

Compiled 61 to 40 computations (34.4% saved)

regimes16.0ms (0.2%)

Memory
-12.4MiB live, 29.0MiB allocated
Counts
2 → 2
Calls
Call 1
Inputs
#s(literal 0 binary64)
(sqrt.f64 re)
Outputs
#s(literal 0 binary64)
(sqrt.f64 re)
Calls

7 calls:

6.0ms
(*.f64 im im)
2.0ms
im
2.0ms
re
2.0ms
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
2.0ms
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
Results
AccuracySegmentsBranch
29.4%1(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
29.4%1(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
29.4%1(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
29.4%1(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
29.4%1(*.f64 im im)
29.4%1im
33.2%2re
Compiler

Compiled 69 to 45 computations (34.8% saved)

regimes10.0ms (0.1%)

Memory
-13.6MiB live, 26.0MiB allocated
Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts
1 → 1
Calls
Call 1
Inputs
#s(literal 0 binary64)
Outputs
#s(literal 0 binary64)
Calls

7 calls:

1.0ms
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
1.0ms
im
1.0ms
re
1.0ms
(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
1.0ms
(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
Results
AccuracySegmentsBranch
5.4%1(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
5.4%1(sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
5.4%1im
5.4%1(*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
5.4%1(+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
5.4%1(*.f64 im im)
5.4%1re
Compiler

Compiled 69 to 45 computations (34.8% saved)

bsearch45.0ms (0.5%)

Memory
10.4MiB live, 88.8MiB allocated
Algorithm
3×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
12.0ms
3.9197314746115664e+117
1.172267536924739e+119
8.0ms
8.400818848563023e-66
2.456870788682077e-65
22.0ms
-1.5651752865132086e-28
-2.2301355716950595e-36
Samples
17.0ms270×0valid
6.0ms30×2valid
4.0ms29×1valid
2.0ms7×3valid
Compiler

Compiled 630 to 457 computations (27.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 20.0ms
ival-hypot: 9.0ms (44.9% of total)
ival-mult: 5.0ms (24.9% of total)
ival-sqrt: 3.0ms (15% of total)
ival-add: 2.0ms (10% of total)
adjust: 1.0ms (5% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

bsearch85.0ms (0.9%)

Memory
-1.3MiB live, 77.3MiB allocated
Algorithm
3×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
37.0ms
3.9197314746115664e+117
1.172267536924739e+119
8.0ms
8.400818848563023e-66
2.456870788682077e-65
37.0ms
-1.5651752865132086e-28
-2.2301355716950595e-36
Samples
44.0ms276×0valid
19.0ms20×1valid
7.0ms37×2valid
1.0ms3×3valid
Compiler

Compiled 582 to 421 computations (27.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 61.0ms
ival-add: 45.0ms (73.3% of total)
ival-hypot: 7.0ms (11.4% of total)
ival-mult: 4.0ms (6.5% of total)
ival-sqrt: 3.0ms (4.9% of total)
adjust: 1.0ms (1.6% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

bsearch56.0ms (0.6%)

Memory
6.8MiB live, 45.8MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
34.0ms
6.623677578817942e+24
1.1004465407065743e+29
19.0ms
-1.5651752865132086e-28
-2.2301355716950595e-36
Samples
35.0ms208×0valid
5.0ms40×1valid
4.0ms21×2valid
1.0ms3×3valid
Compiler

Compiled 363 to 297 computations (18.2% saved)

Precisions
Click to see histograms. Total time spent on operations: 37.0ms
ival-add: 23.0ms (62.1% of total)
ival-hypot: 6.0ms (16.2% of total)
ival-mult: 4.0ms (10.8% of total)
ival-sqrt: 2.0ms (5.4% of total)
adjust: 1.0ms (2.7% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

bsearch48.0ms (0.5%)

Memory
-12.8MiB live, 72.4MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
19.0ms
6.623677578817942e+24
1.1004465407065743e+29
26.0ms
-1.5651752865132086e-28
-2.2301355716950595e-36
Samples
19.0ms204×0valid
8.0ms27×1valid
6.0ms36×2valid
1.0ms5×3valid
Compiler

Compiled 346 to 280 computations (19.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 22.0ms
ival-sqrt: 8.0ms (36.9% of total)
ival-hypot: 7.0ms (32.3% of total)
ival-mult: 4.0ms (18.5% of total)
ival-add: 2.0ms (9.2% of total)
adjust: 1.0ms (4.6% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

bsearch13.0ms (0.1%)

Memory
17.5MiB live, 17.5MiB allocated
Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
12.0ms
6.623677578817942e+24
1.1004465407065743e+29
Samples
8.0ms128×0valid
Compiler

Compiled 132 to 110 computations (16.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 5.0ms
ival-hypot: 2.0ms (39.1% of total)
ival-add: 1.0ms (19.6% of total)
ival-mult: 1.0ms (19.6% of total)
ival-sqrt: 1.0ms (19.6% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch35.0ms (0.4%)

Memory
-14.6MiB live, 24.5MiB allocated
Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
34.0ms
-7.87356238665389e-302
2.9077146166212502e-297
Samples
29.0ms160×0valid
Compiler

Compiled 110 to 94 computations (14.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 25.0ms
ival-mult: 20.0ms (79.8% of total)
ival-hypot: 2.0ms (8% of total)
ival-add: 1.0ms (4% of total)
ival-sqrt: 1.0ms (4% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

simplify11.0ms (0.1%)

Memory
17.2MiB live, 17.2MiB allocated
Algorithm
1×egg-herbie
Rules
26×*-commutative_binary64
10×+-commutative_binary64
2×sub0-neg_binary64
2×sub-neg_binary64
2×1-exp_binary64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
079171
1100171
2103171
3104171
Stop Event
1×saturated
Calls
Call 1
Inputs
(if (<=.f64 re #s(literal -1730417938599789/46768052394588893382517914646921056628989841375232 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 8062834757772801/474284397516047136454946754595585670566993857190463750305618264096412179005177856 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64))))) (if (<=.f64 re #s(literal 29000000000000001606091450439968743772459016428814862474196806344110346086584795579139759884806863444624939613339779072 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))) re)))) (sqrt.f64 re))))
(if (<=.f64 re #s(literal -8418249431026001/93536104789177786765035829293842113257979682750464 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 6877123763982683/474284397516047136454946754595585670566993857190463750305618264096412179005177856 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64))))) (if (<=.f64 re #s(literal 58000000000000003212182900879937487544918032857629724948393612688220692173169591158279519769613726889249879226679558144 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))) (sqrt.f64 re))))
(if (<=.f64 re #s(literal -6565339386447415/5708990770823839524233143877797980545530986496 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 10000000000000000905969664 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re))) (sqrt.f64 re)))
(if (<=.f64 re #s(literal -1462928885023609/178405961588244985132285746181186892047843328 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 1300000000000000044761612288 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)))) (sqrt.f64 re)))
(if (<=.f64 re #s(literal 960000000000000018253611008 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64)))) (sqrt.f64 re))
(if (<=.f64 re #s(literal -101201126653655/202402253307310618352495346718917307049556649764142118356901358027430339567995346891960383701437124495187077864316811911389808737385793476867013399940738509921517424276566361364466907742093216341239767678472745068562007483424692698618103355649159556340810056512358769552333414615230502532186327508646006263307707741093494784 binary64)) #s(literal 0 binary64) (sqrt.f64 re))
#s(literal 0 binary64)
Outputs
(if (<=.f64 re #s(literal -1730417938599789/46768052394588893382517914646921056628989841375232 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 8062834757772801/474284397516047136454946754595585670566993857190463750305618264096412179005177856 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64))))) (if (<=.f64 re #s(literal 29000000000000001606091450439968743772459016428814862474196806344110346086584795579139759884806863444624939613339779072 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))) re)))) (sqrt.f64 re))))
(if (<=.f64 re #s(literal -1730417938599789/46768052394588893382517914646921056628989841375232 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 8062834757772801/474284397516047136454946754595585670566993857190463750305618264096412179005177856 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64))))) (if (<=.f64 re #s(literal 29000000000000001606091450439968743772459016428814862474196806344110346086584795579139759884806863444624939613339779072 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))))) (sqrt.f64 re))))
(if (<=.f64 re #s(literal -8418249431026001/93536104789177786765035829293842113257979682750464 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 6877123763982683/474284397516047136454946754595585670566993857190463750305618264096412179005177856 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64))))) (if (<=.f64 re #s(literal 58000000000000003212182900879937487544918032857629724948393612688220692173169591158279519769613726889249879226679558144 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))) (sqrt.f64 re))))
(if (<=.f64 re #s(literal -8418249431026001/93536104789177786765035829293842113257979682750464 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 6877123763982683/474284397516047136454946754595585670566993857190463750305618264096412179005177856 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 #s(literal 2 binary64) (/.f64 re im)) (*.f64 im #s(literal 2 binary64))))) (if (<=.f64 re #s(literal 58000000000000003212182900879937487544918032857629724948393612688220692173169591158279519769613726889249879226679558144 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (sqrt.f64 re))))
(if (<=.f64 re #s(literal -6565339386447415/5708990770823839524233143877797980545530986496 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 10000000000000000905969664 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re))) (sqrt.f64 re)))
(if (<=.f64 re #s(literal -6565339386447415/5708990770823839524233143877797980545530986496 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 10000000000000000905969664 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 re im))) (sqrt.f64 re)))
(if (<=.f64 re #s(literal -1462928885023609/178405961588244985132285746181186892047843328 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 1300000000000000044761612288 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 im re)))) (sqrt.f64 re)))
(if (<=.f64 re #s(literal -1462928885023609/178405961588244985132285746181186892047843328 binary64)) (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))) (if (<=.f64 re #s(literal 1300000000000000044761612288 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 re im)))) (sqrt.f64 re)))
(if (<=.f64 re #s(literal 960000000000000018253611008 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64)))) (sqrt.f64 re))
(if (<=.f64 re #s(literal -101201126653655/202402253307310618352495346718917307049556649764142118356901358027430339567995346891960383701437124495187077864316811911389808737385793476867013399940738509921517424276566361364466907742093216341239767678472745068562007483424692698618103355649159556340810056512358769552333414615230502532186327508646006263307707741093494784 binary64)) #s(literal 0 binary64) (sqrt.f64 re))
#s(literal 0 binary64)

soundness730.0ms (7.5%)

Memory
20.6MiB live, 768.8MiB allocated
Rules
10 342×accelerator-lowering-fma.f32
10 342×accelerator-lowering-fma.f64
7 766×*-lowering-*.f32
7 766×*-lowering-*.f64
5 816×accelerator-lowering-fma.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
029108
110691
254091
3525579
0863879
027115
1155103
21355103
08541100
05003104
116592919
259062897
080792716
01265
15365
239065
3421565
0833438
Stop Event
1×fuel
1×iter limit
1×node limit
1×iter limit
1×node limit
1×iter limit
1×node limit
1×iter limit
1×node limit
Compiler

Compiled 458 to 296 computations (35.4% saved)

preprocess70.0ms (0.7%)

Memory
-6.3MiB live, 152.4MiB allocated
Compiler

Compiled 580 to 294 computations (49.3% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...