math.sqrt on complex, imaginary part, im greater than 0 branch

Time bar (total: 9.5s)

analyze92.0ms (1%)

Memory
-8.6MiB live, 188.8MiB allocated
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%50%50%0%0%0%0
0%0%50%50%0%0%0%1
50%25%25%50%0%0%0%2
50%25%25%50%0%0%0%3
62.5%31.2%18.7%50%0%0%0%4
62.5%31.2%18.7%50%0%0%0%5
68.8%34.3%15.6%50%0%0%0%6
68.8%34.3%15.6%50%0%0%0%7
71.9%35.9%14%50%0%0%0%8
71.9%35.9%14%50%0%0%0%9
73.4%36.7%13.3%50%0%0%0%10
73.4%36.7%13.3%50%0%0%0%11
74.2%37.1%12.9%50%0%0%0%12
Compiler

Compiled 19 to 12 computations (36.8% saved)

sample1.5s (15.6%)

Memory
17.8MiB live, 1 908.7MiB allocated
Samples
671.0ms6 259×0valid
195.0ms774×2valid
168.0ms783×1valid
165.0ms440×3valid
Precisions
Click to see histograms. Total time spent on operations: 814.0ms
ival-hypot: 366.0ms (44.9% of total)
ival-mult: 163.0ms (20% of total)
ival-sub: 132.0ms (16.2% of total)
ival-sqrt: 84.0ms (10.3% of total)
adjust: 33.0ms (4.1% of total)
ival->: 21.0ms (2.6% of total)
exact: 12.0ms (1.5% of total)
ival-assert: 3.0ms (0.4% of total)
Bogosity

preprocess56.0ms (0.6%)

Memory
41.7MiB live, 115.6MiB allocated
Algorithm
2×egg-herbie
Rules
368×accelerator-lowering-fma.f32
368×accelerator-lowering-fma.f64
228×*-lowering-*.f32
228×*-lowering-*.f64
136×distribute-rgt-in
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03692
17990
216090
329590
443490
552490
664790
778590
883990
01215
11715
22815
34415
46515
59015
614615
721815
830215
935215
1041215
1142615
1244615
1346815
1449815
1552915
1654115
1754315
054310
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 (fma.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64)))) re) #s(literal 0 binary64))))
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 (- (sqrt (+ (* (neg re) (neg re)) (* im im))) (neg re)))))
(* 1/2 (sqrt (* 2 (+ re (sqrt (+ (* re re) (* im im)))))))
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* (neg im) (neg im)))) re))))
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
(neg (* 1/2 (sqrt (* 2 (- (sqrt (+ (* (neg re) (neg re)) (* im im))) (neg re))))))
(* (sqrt (* 2 (+ re (sqrt (+ (* re re) (* im im)))))) -1/2)
(neg (* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* (neg im) (neg im)))) re)))))
(* (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))) -1/2)
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* im im) (* re re))) im))))
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) im))))
Symmetry

(abs im)

explain182.0ms (1.9%)

Memory
-36.2MiB live, 395.5MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1200-0-(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
350-0-(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
280-1(1.5054179252063412e-295 5.90726706032665e-309)(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 #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-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-rescue1000
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow100
↳(*.f64 re re)overflow64
↳(*.f64 im im)overflow53
-.f64(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)cancellation350
sqrt.f64(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))uflow-rescue270
↳(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))underflow32
↳(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))underflow5
↳(*.f64 re re)underflow55
↳(*.f64 im im)underflow66
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow20
↳(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)underflow32
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue200
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow20
↳(*.f64 re re)underflow55
↳(*.f64 im im)underflow66
Confusion
Predicted +Predicted -
+1550
-0101
Precision
1.0
Recall
1.0
Confusion?
Predicted +Predicted MaybePredicted -
+15500
-00101
Precision?
1.0
Recall?
1.0
Freqs
test
numberfreq
0101
1128
227
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
36.0ms382×0valid
15.0ms60×2valid
9.0ms50×1valid
8.0ms20×3valid
Compiler

Compiled 188 to 52 computations (72.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 47.0ms
ival-hypot: 17.0ms (35.8% of total)
ival-mult: 15.0ms (31.6% of total)
ival-sqrt: 5.0ms (10.5% of total)
ival-sub: 4.0ms (8.4% of total)
adjust: 3.0ms (6.3% of total)
ival-add: 3.0ms (6.3% of total)
exact: 1.0ms (2.1% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.7MiB live, 0.7MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

Memory
2.5MiB live, 2.5MiB allocated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶42.9%
(*.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)

simplify31.0ms (0.3%)

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

Found 4 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(-.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-diff192
(+.f64 (*.f64 re re) (*.f64 im im))
Rules
368×accelerator-lowering-fma.f32
368×accelerator-lowering-fma.f64
228×*-lowering-*.f32
228×*-lowering-*.f64
104×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01275
11775
22875
34475
46575
59075
614675
721875
830275
935275
1041275
1142675
1244675
1346875
1449875
1552975
1654175
1754375
054349
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 (fma.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64)))) re) #s(literal 0 binary64))))
1/2
#s(literal 1/2 binary64)
(sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re)))
(sqrt.f64 (fma.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64)))) re) #s(literal 0 binary64)))
(* 2 (- (sqrt (+ (* re re) (* im im))) re))
(fma.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64)))) re) #s(literal 0 binary64))
2
#s(literal 2 binary64)
(- (sqrt (+ (* re re) (* im im))) re)
(-.f64 (sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64)))) re)
(sqrt (+ (* re re) (* im im)))
(sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64))))
(+ (* re re) (* im im))
(fma.f64 re re (fma.f64 im im #s(literal 0 binary64)))
(* re re)
(fma.f64 re re #s(literal 0 binary64))
re
(* im im)
(fma.f64 im im #s(literal 0 binary64))
im

localize50.0ms (0.5%)

Memory
-6.8MiB live, 112.2MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
✓accuracy89.8%
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
✓accuracy87.8%
(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
✓accuracy56.3%
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Samples
18.0ms191×0valid
7.0ms30×2valid
4.0ms25×1valid
3.0ms10×3valid
Compiler

Compiled 77 to 14 computations (81.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 22.0ms
ival-hypot: 7.0ms (31.6% of total)
ival-mult: 7.0ms (31.6% of total)
ival-sqrt: 3.0ms (13.6% of total)
ival-sub: 2.0ms (9% of total)
adjust: 1.0ms (4.5% of total)
ival-add: 1.0ms (4.5% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

series22.0ms (0.2%)

Memory
0.6MiB live, 38.9MiB 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 (- (sqrt (+ (* re re) (* im im))) re)>
#<alt (sqrt (+ (* re re) (* im im)))>
#<alt (* 2 (- (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/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (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 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))>
#<alt (+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))>
#<alt (+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))))>
#<alt (+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/1024 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))))>
#<alt (* -1/2 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2))))>
#<alt (* -1 (* re (+ (* -1/8 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/64 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))>
#<alt (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))>
#<alt (* im (+ (* -1/32 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))))))>
#<alt (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/4 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re)))))))>
#<alt (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/4 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/4 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/2))))))))))>
#<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/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -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/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/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (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/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (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 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))>
#<alt (+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))>
#<alt (+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/512 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))))>
#<alt (* -1 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2))))>
#<alt (* -1 (* re (+ (* -1/4 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/32 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* im (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))))>
#<alt (* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re)))))))>
#<alt (* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/2 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/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/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (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/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (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 im>
#<alt (+ im (* -1 re))>
#<alt (+ im (* re (- (* 1/2 (/ re im)) 1)))>
#<alt (+ im (* re (- (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))) 1)))>
#<alt (* 1/2 (/ (pow im 2) re))>
#<alt (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re)>
#<alt (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re)>
#<alt (/ (+ (* -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 (* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* 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 (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))>
#<alt (* (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 (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/128 (/ (pow im 2) (pow re 7))) (* 1/16 (/ 1 (pow re 5))))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))>
#<alt im>
#<alt (* im (+ 1 (* -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 (/ re im))))>
#<alt (* -1 (* im (+ 1 (* -1 (/ (- (* -1/2 (/ (pow re 2) im)) re) im)))))>
#<alt (* -1 (* im (+ 1 (* -1 (/ (- (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im)) 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 (* 2 im)>
#<alt (+ (* -2 re) (* 2 im))>
#<alt (+ (* 2 im) (* re (- (/ re im) 2)))>
#<alt (+ (* 2 im) (* re (- (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))) 2)))>
#<alt (/ (pow im 2) re)>
#<alt (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re)>
#<alt (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re)>
#<alt (/ (+ (* -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 (* -1 (* re (+ 4 (/ (pow im 2) (pow re 2)))))>
#<alt (* -1 (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* 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 (/ (pow im 2) re)>
#<alt (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re)))>
#<alt (* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re)))>
#<alt (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/64 (/ (pow im 2) (pow re 7))) (* 1/8 (/ 1 (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 (+ (* -2 (/ re im)) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))>
#<alt (* -2 im)>
#<alt (* -1 (* im (+ 2 (* 2 (/ re im)))))>
#<alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (pow re 2) im))) im)))))>
#<alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im))) im)))))>
Calls

36 calls:

TimeVariablePointExpression
4.0ms
im
@inf
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
2.0ms
im
@0
(* 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
re
@-inf
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
1.0ms
im
@inf
(sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re)))

rewrite349.0ms (3.7%)

Memory
1.6MiB live, 679.9MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 708×accelerator-lowering-fma.f32
5 708×accelerator-lowering-fma.f64
3 650×*-lowering-*.f32
3 650×*-lowering-*.f64
2 118×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01265
14865
236665
3418165
0838138
Stop Event
1×iter limit
1×node limit
Counts
6 → 292
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)))
(- (sqrt (+ (* re re) (* im im))) re)
(sqrt (+ (* re re) (* im im)))
(* 2 (- (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 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 (*.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(fabs.f64 (fma.f64 im im (*.f64 re re)))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (*.f64 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 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 #s(literal 0 binary64) re) (*.f64 im im))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) (*.f64 im im))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 re re)) (*.f64 im 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 #s(literal 0 binary64) re) #s(literal -1 binary64)) re (*.f64 im im))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 im im (*.f64 re re)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.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 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))
(/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.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 im im (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 im im (*.f64 re re)) (*.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 (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 (*.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 (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 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 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im 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 (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 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 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im 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 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 re 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 im (*.f64 im (*.f64 im im))))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 im im (*.f64 re re)) (*.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 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.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 im im (*.f64 re re))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 (*.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 (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im 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 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 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 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (-.f64 re im))
(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))
(pow.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 4 binary64))
(pow.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) #s(literal 1/4 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1 binary64))
(*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (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 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 #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 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 im im (*.f64 re re)) (*.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 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 im im (*.f64 re re)))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 re re) (*.f64 (*.f64 (*.f64 re (*.f64 re 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 re (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 re im) (-.f64 im re))))) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re 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 (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64))) (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/2 binary64))))
(exp.f64 (fma.f64 (log.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/4 binary64) (*.f64 (log.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/4 binary64))))
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(sqrt.f64 (exp.f64 (log.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 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 re im) (-.f64 im re))))) (sqrt.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)) (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)))
(+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (-.f64 #s(literal 0 binary64) re))
(+.f64 (-.f64 #s(literal 0 binary64) re) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (/.f64 (*.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)))) (neg.f64 (/.f64 (*.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 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal -1 binary64)))
(-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)
(-.f64 (/.f64 (*.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 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 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(-.f64 #s(literal 0 binary64) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(-.f64 (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 0 binary64)) 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 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(fma.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (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)))) (neg.f64 (/.f64 (*.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))))))
(fma.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (/.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(fma.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (/.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)))) (neg.f64 (/.f64 (*.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))))))
(fma.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (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)))) (/.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)))) (neg.f64 (/.f64 (*.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))))))
(fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (/.f64 (*.f64 re re) (+.f64 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 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (-.f64 #s(literal 0 binary64) re))
(fma.f64 #s(literal -1 binary64) re (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(fma.f64 (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (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)))) (neg.f64 (/.f64 (*.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))))))
(fma.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(fma.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.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))) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(fma.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (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 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (+.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))))) (neg.f64 (/.f64 (*.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))))))
(fma.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (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 (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)))))) (neg.f64 (/.f64 (*.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 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 re im) (-.f64 im re))) (-.f64 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.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)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (fma.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 (fma.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 re (-.f64 (fma.f64 im im (*.f64 re re)) (neg.f64 (*.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 re im) (-.f64 im re)))) (-.f64 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (-.f64 (*.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 (*.f64 re (*.f64 re 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)) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.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 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 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.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 re (*.f64 re re)))) (*.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 (*.f64 re re) (fma.f64 re re (fma.f64 im im (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(/.f64 (*.f64 (fma.f64 re re (fma.f64 im im (*.f64 re re))) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 re re (fma.f64 im im (*.f64 re re)))))
(/.f64 (-.f64 (*.f64 (*.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 (fma.f64 re (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (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))) (fma.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 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.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))))))
(/.f64 (*.f64 (-.f64 (*.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 (*.f64 re (*.f64 re 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)) (fma.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 (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 re (*.f64 re re)))) #s(literal 1 binary64)) (*.f64 (fma.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 (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 re (*.f64 re re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re re) (fma.f64 re re (fma.f64 im im (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (+.f64 re (sqrt.f64 (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 re im) (-.f64 im re)))) #s(literal 1 binary64)) (*.f64 (fma.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 (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1 binary64)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 re im) (-.f64 im re))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.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)))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.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)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.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 (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)))) (fma.f64 (/.f64 (*.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 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 (*.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 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 (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 3 binary64)) (*.f64 (*.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (fma.f64 (/.f64 (fma.f64 im im (*.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 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 (-.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re))) (-.f64 (-.f64 #s(literal 0 binary64) re) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.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 (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 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 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)))))) (fma.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (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 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 (*.f64 (/.f64 (fma.f64 im im (*.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)))))) (*.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (+.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 (-.f64 (*.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 (*.f64 re (*.f64 re 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)) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 (*.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 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 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.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 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (fma.f64 (*.f64 re re) (fma.f64 re re (fma.f64 im im (*.f64 re re))) (*.f64 (fma.f64 im im (*.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 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (fma.f64 re re (fma.f64 im im (*.f64 re re))))
(pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re 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 (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 im im (*.f64 re 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 (sqrt.f64 (fma.f64 im im (*.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 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re 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 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.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)))) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (fma.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 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
(*.f64 (/.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (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 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (+.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 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (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 (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)))))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (fma.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))))
(hypot.f64 re im)
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 im re)
(hypot.f64 im (-.f64 #s(literal 0 binary64) re))
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 (-.f64 #s(literal 0 binary64) re) im)
(hypot.f64 (-.f64 #s(literal 0 binary64) 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)) (-.f64 #s(literal 0 binary64) 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 (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 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.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 re (*.f64 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 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 im im (*.f64 re re)) (*.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 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) #s(literal 1/8 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 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 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(+.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)))))
(fma.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 #s(literal -2 binary64) re))
(fma.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) re) (*.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 (-.f64 #s(literal 0 binary64) re) #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(fma.f64 #s(literal -1 binary64) (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(fma.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64)) (*.f64 #s(literal -2 binary64) re))
(fma.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal -2 binary64) re))
(fma.f64 #s(literal -2 binary64) re (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 2 binary64) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) 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 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 #s(literal 2 binary64) (fma.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 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 re im) (-.f64 im re))))) (-.f64 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (fma.f64 (*.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 (*.f64 (*.f64 #s(literal -2 binary64) re) (*.f64 #s(literal -2 binary64) re)) (*.f64 #s(literal -2 binary64) re))) (fma.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (-.f64 (*.f64 (*.f64 #s(literal -2 binary64) re) (*.f64 #s(literal -2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal -2 binary64) re)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (*.f64 #s(literal -2 binary64) re) (*.f64 #s(literal -2 binary64) re))) (-.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) (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 re im) (-.f64 im re))))) (-.f64 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 re im) (-.f64 im re)))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(pow.f64 (/.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 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re 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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
(*.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) #s(literal 2 binary64))
(*.f64 (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.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 (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 #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 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)))
(*.f64 (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re 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 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (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 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (+.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 re (*.f64 re re) (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (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 (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 re im) (-.f64 im re)))) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.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))))

simplify568.0ms (6%)

Memory
-9.5MiB live, 903.8MiB allocated
Algorithm
1×egg-herbie
Rules
11 848×accelerator-lowering-fma.f32
11 848×accelerator-lowering-fma.f64
8 470×*-lowering-*.f32
8 470×*-lowering-*.f64
3 078×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
05513257
118143103
263803088
081982913
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/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (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 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))
(+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))
(+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))))
(+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/1024 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))))
(* -1/2 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2))))
(* -1 (* re (+ (* -1/8 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/64 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))
(* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))
(* im (+ (* -1/32 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))))))
(* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/4 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re)))))))
(* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/4 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/4 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/2))))))))))
(* 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/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -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/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/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (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/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (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)))
(* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))
(+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))
(+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))
(+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/512 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))))
(* -1 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2))))
(* -1 (* re (+ (* -1/4 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/32 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))
(* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))
(* im (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))))
(* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re)))))))
(* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/2 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/2))))))))))
(* (sqrt im) (sqrt 2))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (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/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (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)))))))
im
(+ im (* -1 re))
(+ im (* re (- (* 1/2 (/ re im)) 1)))
(+ im (* re (- (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))) 1)))
(* 1/2 (/ (pow im 2) re))
(/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re)
(/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re)
(/ (+ (* -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 (* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* 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))
(* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))
(* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))
(* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/128 (/ (pow im 2) (pow re 7))) (* 1/16 (/ 1 (pow re 5))))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))
im
(* im (+ 1 (* -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 (/ re im))))
(* -1 (* im (+ 1 (* -1 (/ (- (* -1/2 (/ (pow re 2) im)) re) im)))))
(* -1 (* im (+ 1 (* -1 (/ (- (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im)) 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))))))))
(* 2 im)
(+ (* -2 re) (* 2 im))
(+ (* 2 im) (* re (- (/ re im) 2)))
(+ (* 2 im) (* re (- (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))) 2)))
(/ (pow im 2) re)
(/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re)
(/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re)
(/ (+ (* -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)
(* -1 (* re (+ 4 (/ (pow im 2) (pow re 2)))))
(* -1 (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/8 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))))
(/ (pow im 2) re)
(* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re)))
(* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re)))
(* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/64 (/ (pow im 2) (pow re 7))) (* 1/8 (/ 1 (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 (+ (* -2 (/ re im)) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
(* -2 im)
(* -1 (* im (+ 2 (* 2 (/ re im)))))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (pow re 2) im))) im)))))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 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 #s(literal -1/4 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (*.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))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (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 #s(literal -1/4 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))) (*.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 (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) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/32 binary64)))) (*.f64 #s(literal -1/4 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))) (*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))
(*.f64 im (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))
(fma.f64 im (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) (*.f64 (/.f64 (*.f64 #s(literal -1/32 binary64) (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))))
(+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))))
(fma.f64 im (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) (fma.f64 (/.f64 (*.f64 #s(literal -1/32 binary64) (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 (*.f64 #s(literal 1/64 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))))))
(+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/1024 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (fma.f64 #s(literal -1/512 binary64) (*.f64 (pow.f64 im #s(literal 5 binary64)) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (*.f64 #s(literal 1/64 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))))) (fma.f64 im (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))) (*.f64 (/.f64 (*.f64 #s(literal -1/32 binary64) (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
(* -1/2 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2))))
(*.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -1 binary64))) #s(literal -1 binary64))
(* -1 (* re (+ (* -1/8 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))
(*.f64 (fma.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 im im)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64)))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))
(*.f64 (-.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) (/.f64 (fma.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 re) #s(literal 1/8 binary64)))) (*.f64 re (*.f64 re re)))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/64 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))
(*.f64 (-.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (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/32 binary64) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 #s(literal 1/64 binary64) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) #s(literal 2 binary64))))) (*.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 re) #s(literal 1/8 binary64)))) (*.f64 re (*.f64 re re)))) (-.f64 #s(literal 0 binary64) re))
(* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))
(*.f64 im (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(* im (+ (* -1/32 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))))))
(*.f64 im (fma.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1/2 binary64)) (*.f64 (/.f64 (*.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im)) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
(* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/4 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re)))))))
(*.f64 im (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/32 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (*.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im) (/.f64 (-.f64 (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/128 binary64) (pow.f64 re #s(literal 5 binary64)))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 re) #s(literal 1/4 binary64)))) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
(* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/4 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/4 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/2))))))))))
(*.f64 im (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (-.f64 (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/128 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 re re)) (/.f64 #s(literal 5/128 binary64) (pow.f64 re #s(literal 7 binary64))))) (*.f64 (*.f64 im im) (sqrt.f64 re))) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (sqrt.f64 re)) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (-.f64 (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/128 binary64) (pow.f64 re #s(literal 5 binary64)))))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 #s(literal -1/32 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))))) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
(* 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 #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/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (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) (*.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) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 re (*.f64 re (sqrt.f64 #s(literal 2 binary64)))) #s(literal 1/8 binary64))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -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/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 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 re (*.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))))))
(* -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/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)))))) (*.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 #s(literal 0 binary64) im))
(* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (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 (*.f64 #s(literal -1/8 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 re re))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 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)))))) (-.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 (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 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 im) #s(literal 3/16 binary64))) (-.f64 #s(literal 0 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/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (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 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (*.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 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (*.f64 (sqrt.f64 im) (sqrt.f64 #s(literal 2 binary64))))
(* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))
(*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))
(fma.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 im (*.f64 im im))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))))
(+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))
(fma.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (fma.f64 (*.f64 (*.f64 #s(literal 1/32 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (*.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 im (*.f64 im im))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
(+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/512 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (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 (/.f64 (*.f64 im (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im)) (sqrt.f64 #s(literal 1/2 binary64))) #s(literal -1/16 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 9 binary64)))) (fma.f64 #s(literal -1/256 binary64) (*.f64 (pow.f64 im #s(literal 5 binary64)) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (*.f64 #s(literal 1/32 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* -1 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2))))
(*.f64 (sqrt.f64 re) (*.f64 #s(literal -2 binary64) (sqrt.f64 #s(literal -1 binary64))))
(* -1 (* re (+ (* -1/4 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal -1 binary64)))) #s(literal -1/4 binary64)) (*.f64 #s(literal 2 binary64) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (-.f64 (*.f64 #s(literal 2 binary64) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (/.f64 (fma.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (*.f64 im im) (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 re) #s(literal 1/4 binary64)))) (*.f64 re (*.f64 re re))))))
(* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/32 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (-.f64 (*.f64 #s(literal 2 binary64) (*.f64 (sqrt.f64 #s(literal -1 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 (*.f64 #s(literal -1/16 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (sqrt.f64 #s(literal -1 binary64)) (*.f64 (*.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 2 binary64)))) (*.f64 (*.f64 im (*.f64 im (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 re) #s(literal 1/4 binary64)))) (*.f64 re (*.f64 re re))))))
(* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))
(*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))))
(*.f64 im (fma.f64 (/.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im)) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re)))))))
(*.f64 im (fma.f64 (*.f64 im 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)) (sqrt.f64 #s(literal 1/2 binary64))) #s(literal -1/16 binary64)) (*.f64 (*.f64 im im) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 (-.f64 (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/128 binary64) (pow.f64 re #s(literal 5 binary64)))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 re) #s(literal 1/2 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/2 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/2))))))))))
(*.f64 im (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (-.f64 (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/128 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 re re)) (/.f64 #s(literal 5/128 binary64) (pow.f64 re #s(literal 7 binary64))))) (*.f64 (*.f64 im im) (sqrt.f64 re))) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 (-.f64 (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/128 binary64) (pow.f64 re #s(literal 5 binary64)))) (sqrt.f64 #s(literal 1/2 binary64)))) (*.f64 (sqrt.f64 re) #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 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) #s(literal -1/16 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) 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/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (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 (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/4 binary64))))))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (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 (/.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)) (*.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 (-.f64 #s(literal 0 binary64) (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 #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 (sqrt.f64 #s(literal -1 binary64)) re)) #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/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -1) (sqrt 2))))) (* (sqrt (/ 1 im)) (* (sqrt -1) (sqrt 2)))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) re)) #s(literal -1/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) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))))) (*.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 (-.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) re)) #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 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (sqrt.f64 im) #s(literal 3/8 binary64))) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) im))
im
(+ im (* -1 re))
(-.f64 im re)
(+ im (* re (- (* 1/2 (/ re im)) 1)))
(fma.f64 re (fma.f64 re (/.f64 #s(literal 1/2 binary64) im) #s(literal -1 binary64)) im)
(+ im (* re (- (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))) 1)))
(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)
(* 1/2 (/ (pow im 2) re))
(/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) re)
(/ (+ (* -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))) re)
(/ (+ (* -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/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (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)))) re)
(/ (+ (* -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 (pow.f64 im #s(literal 8 binary64)) (/.f64 #s(literal 5/64 binary64) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (*.f64 re re) (*.f64 re re))) (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))))) re)
(* -2 re)
(*.f64 re #s(literal -2 binary64))
(* -1 (* re (+ 2 (* 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 2 binary64))))
(* -1 (* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(-.f64 #s(literal 0 binary64) (*.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)))))
(* -1 (* 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 (+.f64 #s(literal 2 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (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 (*.f64 re re))) #s(literal 1/2 binary64))))) (-.f64 #s(literal 0 binary64) re))
(* 1/2 (/ (pow im 2) re))
(/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) re)
(* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))
(*.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)))
(* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))
(*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 im (*.f64 im (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)))
(* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/128 (/ (pow im 2) (pow re 7))) (* 1/16 (/ 1 (pow re 5))))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))
(*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 #s(literal -5/128 binary64) (/.f64 (*.f64 im im) (pow.f64 re #s(literal 7 binary64))) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)))
im
(* im (+ 1 (* -1 (/ re im))))
(*.f64 im (-.f64 #s(literal 1 binary64) (/.f64 re im)))
(* im (- (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))) (/ re im)))
(*.f64 im (-.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 1 binary64)) (/.f64 re im)))
(* im (- (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (/ re im)))
(*.f64 im (-.f64 (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #s(literal 1 binary64))) (/.f64 re im)))
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (/ re im))))
(-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 re im) im))
(* -1 (* im (+ 1 (* -1 (/ (- (* -1/2 (/ (pow re 2) im)) re) im)))))
(fma.f64 im (/.f64 (-.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im)) re) im) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 1 (* -1 (/ (- (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im)) re) im)))))
(-.f64 #s(literal 0 binary64) (fma.f64 im (/.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 im im)) (*.f64 re (*.f64 re #s(literal 1/2 binary64)))) im) re) im) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (/.f64 (*.f64 #s(literal 1/2 binary64) 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 (*.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/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (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 (*.f64 re re))) #s(literal 1/2 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 (*.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/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (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 (*.f64 re re))) #s(literal 1/2 binary64)))) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 im (*.f64 im (fma.f64 #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 im (*.f64 im (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(*.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 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.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 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) 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 #s(literal 0 binary64) (*.f64 im (fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) #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 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) im))
(* 2 im)
(*.f64 im #s(literal 2 binary64))
(+ (* -2 re) (* 2 im))
(fma.f64 im #s(literal 2 binary64) (*.f64 re #s(literal -2 binary64)))
(+ (* 2 im) (* re (- (/ re im) 2)))
(fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))
(+ (* 2 im) (* re (- (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))) 2)))
(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)))
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re)
(/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (*.f64 im im)) re)
(/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re)
(/.f64 (fma.f64 im im (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (*.f64 re re) (*.f64 re re))))) re)
(/ (+ (* -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 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 re re)) (-.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)))) (*.f64 (pow.f64 im #s(literal 8 binary64)) (/.f64 #s(literal 5/64 binary64) (pow.f64 re #s(literal 6 binary64)))))) re)
(* -4 re)
(*.f64 re #s(literal -4 binary64))
(* -1 (* re (+ 4 (/ (pow im 2) (pow re 2)))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 im (/.f64 im (*.f64 re re)) #s(literal 4 binary64))))
(* -1 (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
(*.f64 (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))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* 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 (+.f64 (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))) (/.f64 (*.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (-.f64 #s(literal 0 binary64) re))
(/ (pow im 2) re)
(/.f64 (*.f64 im im) re)
(* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re)))
(*.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)))
(* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re)))
(*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 im (*.f64 im (/.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 #s(literal -1/4 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) re)))
(* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/64 (/ (pow im 2) (pow re 7))) (* 1/8 (/ 1 (pow re 5))))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re)))
(*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (pow.f64 re #s(literal 7 binary64))) #s(literal -5/64 binary64) (/.f64 #s(literal 1/8 binary64) (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 im #s(literal 2 binary64))
(* im (+ 2 (* -2 (/ re im))))
(*.f64 im (fma.f64 (/.f64 re im) #s(literal -2 binary64) #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 (/.f64 re im) #s(literal -2 binary64) #s(literal 2 binary64))))
(* im (+ 2 (+ (* -2 (/ re im)) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
(*.f64 im (+.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 (*.f64 re #s(literal -2 binary64)) 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 (-.f64 #s(literal 0 binary64) im) (fma.f64 #s(literal 2 binary64) (/.f64 re im) #s(literal 2 binary64)))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (pow re 2) im))) im)))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 2 binary64) (/.f64 (-.f64 (*.f64 re #s(literal -2 binary64)) (/.f64 (*.f64 re re) im)) im)))
(* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im))) im)))))
(-.f64 #s(literal 0 binary64) (*.f64 im (-.f64 #s(literal 2 binary64) (/.f64 (fma.f64 re #s(literal -2 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (*.f64 re re) (*.f64 re re)) (*.f64 im im)) (*.f64 re re)) (-.f64 #s(literal 0 binary64) im))) im))))

eval175.0ms (1.8%)

Memory
32.2MiB live, 145.8MiB allocated
Compiler

Compiled 15 863 to 2 383 computations (85% saved)

prune95.0ms (1%)

Memory
24.0MiB live, 129.2MiB allocated
Pruning

15 alts after pruning (15 fresh and 0 done)

PrunedKeptTotal
New42115436
Fresh000
Picked101
Done000
Total42215437
Accuracy
99.8%
Counts
437 → 15
Alt Table
Click to see full alt table
StatusAccuracyProgram
42.7%
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (sqrt.f64 #s(literal 2 binary64)))
42.9%
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
50.3%
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
18.6%
(*.f64 im (fma.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1/2 binary64)) (*.f64 (/.f64 (*.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im)) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
27.1%
(*.f64 im (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
17.0%
(*.f64 #s(literal 1/2 binary64) (fma.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 im (*.f64 im im))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
▶27.2%
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
▶50.3%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))))
14.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 im im) re)))
13.5%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.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)))))
26.9%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
▶50.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
▶77.5%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re))))
▶5.3%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 re re))))
52.7%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re))))
Compiler

Compiled 480 to 350 computations (27.1% saved)

simplify417.0ms (4.4%)

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

Found 19 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(/.f64 #s(literal 1 binary64) re)
✓cost-diff0
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
✓cost-diff0
(sqrt.f64 #s(literal 1/2 binary64))
✓cost-diff0
(sqrt.f64 #s(literal 2 binary64))
✓cost-diff0
(+.f64 (/.f64 re im) #s(literal -2 binary64))
✓cost-diff0
(fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))
✓cost-diff0
(sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))))
✓cost-diff0
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 re re)))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 re re))))
✓cost-diff192
(-.f64 re re)
✓cost-diff320
(*.f64 #s(literal 2 binary64) (-.f64 re re))
✓cost-diff-64
(*.f64 im #s(literal 2 binary64))
✓cost-diff0
(sqrt.f64 (*.f64 im #s(literal 2 binary64)))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
✓cost-diff0
(-.f64 (hypot.f64 re im) re)
✓cost-diff0
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re)))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re))))
✓cost-diff5056
(hypot.f64 re im)
Rules
3 024×accelerator-lowering-fma.f32
3 024×accelerator-lowering-fma.f64
2 416×*-lowering-*.f32
2 416×*-lowering-*.f64
1 908×unsub-neg
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
035195
169195
2131195
3288195
4451195
5515195
6625195
7897195
81303195
91726195
102857195
114022195
124110195
134279195
144450195
154478195
165238195
175590195
185590195
195590195
205590195
215590195
225590195
235590195
245596195
05596167
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
im
(* 1/2 (sqrt (* im 2)))
1/2
(sqrt (* im 2))
(* im 2)
im
2
(* 1/2 (sqrt (* 2 (- re re))))
1/2
(sqrt (* 2 (- re re)))
(* 2 (- re re))
2
(- re re)
re
(* 1/2 (sqrt (+ (* re (+ (/ re im) -2)) (* im 2))))
1/2
(sqrt (+ (* re (+ (/ re im) -2)) (* im 2)))
(+ (* re (+ (/ re im) -2)) (* im 2))
re
(+ (/ re im) -2)
(/ re im)
im
-2
(* im 2)
2
(* 1/2 (* (* (sqrt 2) (* (sqrt 1/2) im)) (sqrt (/ 1 re))))
1/2
(* (* (sqrt 2) (* (sqrt 1/2) im)) (sqrt (/ 1 re)))
(* (sqrt 2) (* (sqrt 1/2) im))
(sqrt 2)
2
(* (sqrt 1/2) im)
(sqrt 1/2)
im
(sqrt (/ 1 re))
(/ 1 re)
1
re
Outputs
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 #s(literal -2 binary64) (-.f64 re (sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64))))) #s(literal 0 binary64))))
1/2
#s(literal 1/2 binary64)
(sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re)))
(sqrt.f64 (fma.f64 #s(literal -2 binary64) (-.f64 re (sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64))))) #s(literal 0 binary64)))
(* 2 (- (sqrt (+ (* re re) (* im im))) re))
(fma.f64 #s(literal -2 binary64) (-.f64 re (sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64))))) #s(literal 0 binary64))
2
#s(literal 2 binary64)
(- (sqrt (+ (* re re) (* im im))) re)
(-.f64 (sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64)))) re)
(sqrt (+ (* re re) (* im im)))
(sqrt.f64 (fma.f64 re re (fma.f64 im im #s(literal 0 binary64))))
re
im
(* 1/2 (sqrt (* im 2)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 #s(literal 2 binary64) im #s(literal 0 binary64))))
1/2
#s(literal 1/2 binary64)
(sqrt (* im 2))
(sqrt.f64 (fma.f64 #s(literal 2 binary64) im #s(literal 0 binary64)))
(* im 2)
(fma.f64 #s(literal 2 binary64) im #s(literal 0 binary64))
im
2
#s(literal 2 binary64)
(* 1/2 (sqrt (* 2 (- re re))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 0 binary64)))
1/2
#s(literal 1/2 binary64)
(sqrt (* 2 (- re re)))
(sqrt.f64 #s(literal 0 binary64))
(* 2 (- re re))
#s(literal 0 binary64)
2
#s(literal 2 binary64)
(- re re)
#s(literal 0 binary64)
re
(* 1/2 (sqrt (+ (* re (+ (/ re im) -2)) (* im 2))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 #s(literal 2 binary64) im (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) #s(literal 0 binary64)))))
1/2
#s(literal 1/2 binary64)
(sqrt (+ (* re (+ (/ re im) -2)) (* im 2)))
(sqrt.f64 (fma.f64 #s(literal 2 binary64) im (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) #s(literal 0 binary64))))
(+ (* re (+ (/ re im) -2)) (* im 2))
(fma.f64 #s(literal 2 binary64) im (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) #s(literal 0 binary64)))
re
(+ (/ re im) -2)
(+.f64 (/.f64 re im) #s(literal -2 binary64))
(/ re im)
(/.f64 re im)
im
-2
#s(literal -2 binary64)
(* im 2)
(fma.f64 #s(literal 2 binary64) im #s(literal 0 binary64))
2
#s(literal 2 binary64)
(* 1/2 (* (* (sqrt 2) (* (sqrt 1/2) im)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 #s(literal 1/2 binary64) (fma.f64 im (sqrt.f64 #s(literal 2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
1/2
#s(literal 1/2 binary64)
(* (* (sqrt 2) (* (sqrt 1/2) im)) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 im (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* (sqrt 2) (* (sqrt 1/2) im))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 im (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(sqrt 2)
(sqrt.f64 #s(literal 2 binary64))
2
#s(literal 2 binary64)
(* (sqrt 1/2) im)
(fma.f64 im (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 0 binary64))
(sqrt 1/2)
(sqrt.f64 #s(literal 1/2 binary64))
im
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(/ 1 re)
(/.f64 #s(literal 1 binary64) re)
1
#s(literal 1 binary64)
re

localize230.0ms (2.4%)

Memory
41.6MiB live, 211.7MiB allocated
Localize:

Found 19 expressions of interest:

NewMetricScoreProgram
✓accuracy99.9%
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
✓accuracy99.8%
(*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
✓accuracy99.7%
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im))
✓accuracy99.6%
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)
✓accuracy100.0%
(*.f64 im #s(literal 2 binary64))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))))
✓accuracy99.9%
(fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))
✓accuracy92.3%
(sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))))
✓accuracy100.0%
(-.f64 re re)
✓accuracy100.0%
(*.f64 #s(literal 2 binary64) (-.f64 re re))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 re re))))
✓accuracy100.0%
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 re re)))
✓accuracy100.0%
(*.f64 im #s(literal 2 binary64))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
✓accuracy100.0%
(sqrt.f64 (*.f64 im #s(literal 2 binary64)))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re))))
✓accuracy100.0%
(*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re))
✓accuracy89.8%
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re)))
✓accuracy87.8%
(-.f64 (hypot.f64 re im) re)
Samples
93.0ms133×0invalid
47.0ms25×1valid
15.0ms30×2valid
13.0ms58×0valid
6.0ms10×3valid
Compiler

Compiled 183 to 34 computations (81.4% saved)

Precisions
Click to see histograms. Total time spent on operations: 127.0ms
ival-mult: 53.0ms (41.9% of total)
ival-sub: 26.0ms (20.5% of total)
ival-div: 22.0ms (17.4% of total)
ival-sqrt: 12.0ms (9.5% of total)
ival-hypot: 8.0ms (6.3% of total)
adjust: 3.0ms (2.4% of total)
ival-add: 3.0ms (2.4% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

series31.0ms (0.3%)

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

93 calls:

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

rewrite108.0ms (1.1%)

Memory
5.9MiB live, 127.0MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
590×*-lowering-*.f32
590×*-lowering-*.f64
564×accelerator-lowering-fma.f32
564×accelerator-lowering-fma.f64
360×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
034151
1158140
01017112
Stop Event
1×iter limit
1×iter limit
1×node limit
Counts
23 → 162
Calls
Call 1
Inputs
(sqrt (+ (* re re) (* im im)))
(* 1/2 (sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re))))
(sqrt (* 2 (- (sqrt (+ (* re re) (* im im))) re)))
(- (sqrt (+ (* re re) (* im im))) re)
(* 1/2 (sqrt (* im 2)))
(sqrt (* im 2))
(* im 2)
(* 2 (- re re))
(- re re)
(* 1/2 (sqrt (* 2 (- re re))))
(sqrt (* 2 (- re re)))
(* 1/2 (sqrt (+ (* re (+ (/ re im) -2)) (* im 2))))
(sqrt (+ (* re (+ (/ re im) -2)) (* im 2)))
(+ (* re (+ (/ re im) -2)) (* im 2))
(+ (/ re im) -2)
(sqrt 2)
(sqrt 1/2)
(sqrt (/ 1 re))
(/ 1 re)
(* 2 (- (sqrt (+ (* re re) (* im im))) re))
(* (sqrt 1/2) im)
(* (sqrt 2) (* (sqrt 1/2) im))
(* (* (sqrt 2) (* (sqrt 1/2) im)) (sqrt (/ 1 re)))
Outputs
(exp.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64)))
(hypot.f64 re im)
(hypot.f64 re (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 im re)
(hypot.f64 im (pow.f64 re #s(literal 1 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) im)
(hypot.f64 (pow.f64 re #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) re)
(hypot.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 re #s(literal 1 binary64)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(/.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 (*.f64 im im) (-.f64 (*.f64 im im) (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(*.f64 #s(literal 1/2 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) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(exp.f64 (*.f64 (log.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64)))
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)) (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)))
(+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (-.f64 #s(literal 0 binary64) re))
(+.f64 (-.f64 #s(literal 0 binary64) re) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)
(-.f64 (/.f64 (*.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 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 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(fma.f64 #s(literal -1 binary64) re (sqrt.f64 (fma.f64 im im (*.f64 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)) (-.f64 #s(literal 0 binary64) 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 (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 re re))))
(/.f64 (-.f64 (*.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 (fma.f64 im im (*.f64 re re)) (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re re)))) (neg.f64 (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 im im (*.f64 re re)) (*.f64 re re))) (neg.f64 (+.f64 re (sqrt.f64 (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))) (pow.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 3 binary64))) (+.f64 (fma.f64 im im (*.f64 re re)) (-.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 #s(literal 0 binary64) re)) (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (-.f64 #s(literal 0 binary64) re)))))
(/.f64 (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 #s(literal 0 binary64) re))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (-.f64 #s(literal 0 binary64) re)))
(*.f64 (-.f64 (*.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 (fma.f64 im im (*.f64 re re)) (*.f64 re re)) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re 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 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64)))
(sqrt.f64 (*.f64 im #s(literal 2 binary64)))
(pow.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(*.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 im #s(literal 2 binary64))
(*.f64 #s(literal 2 binary64) im)
#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 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))))
(*.f64 (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))) #s(literal 1/2 binary64))
(exp.f64 (*.f64 (log.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))) #s(literal 1/2 binary64)))
(sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))))
(/.f64 (sqrt.f64 (fma.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))) (*.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))))))) (sqrt.f64 (fma.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))) (*.f64 (*.f64 im #s(literal 2 binary64)) (-.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im)))) (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im))))
(pow.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))) #s(literal 1/4 binary64)))
(+.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))
(+.f64 (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))) (*.f64 im #s(literal 2 binary64)))
(+.f64 (/.f64 (*.f64 re re) im) (fma.f64 re #s(literal -2 binary64) (*.f64 im #s(literal 2 binary64))))
(+.f64 (fma.f64 im #s(literal 2 binary64) (/.f64 (*.f64 re re) im)) (*.f64 re #s(literal -2 binary64)))
(-.f64 (/.f64 (*.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))) (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im))) (/.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im))))
(fma.f64 re (/.f64 re im) (fma.f64 re #s(literal -2 binary64) (*.f64 im #s(literal 2 binary64))))
(fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1 binary64) im) (fma.f64 re #s(literal -2 binary64) (*.f64 im #s(literal 2 binary64))))
(fma.f64 im #s(literal 2 binary64) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))
(fma.f64 #s(literal 2 binary64) im (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))
(fma.f64 (/.f64 re im) re (fma.f64 re #s(literal -2 binary64) (*.f64 im #s(literal 2 binary64))))
(fma.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) re (*.f64 im #s(literal 2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))) (*.f64 (*.f64 im #s(literal 2 binary64)) (-.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))))) (fma.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))) (*.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im)) (*.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im)))))
(/.f64 (fma.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))) (*.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))))) (fma.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))) (*.f64 (*.f64 im #s(literal 2 binary64)) (-.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))))))
(/.f64 (fma.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))) (*.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))))) (fma.f64 (*.f64 im im) #s(literal 4 binary64) (-.f64 (*.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))) (*.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))))))
(/.f64 (*.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im))) (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im)))
(/.f64 (neg.f64 (fma.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))) (*.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))))))) (neg.f64 (fma.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))) (*.f64 (*.f64 im #s(literal 2 binary64)) (-.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im)))) (neg.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im))))
(/.f64 (-.f64 (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))))) (-.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))))
(*.f64 (fma.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 (*.f64 im im) #s(literal 4 binary64)) (*.f64 (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))) (*.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)))) (*.f64 (*.f64 im #s(literal 2 binary64)) (-.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64))))))))
(*.f64 (*.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64))) (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 #s(literal -2 binary64) im))))
(+.f64 (/.f64 re im) #s(literal -2 binary64))
(+.f64 #s(literal -2 binary64) (/.f64 re im))
(-.f64 (/.f64 (/.f64 (*.f64 re re) (*.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 #s(literal 1 binary64) (/.f64 re 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 #s(literal 1 binary64) im) re #s(literal -2 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 4 binary64) (/.f64 (*.f64 re #s(literal -2 binary64)) im))) (fma.f64 (/.f64 re im) (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -8 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 re im) #s(literal 2 binary64)) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -4 binary64))))
(/.f64 (fma.f64 (/.f64 re im) (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -8 binary64)) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 4 binary64) (/.f64 (*.f64 re #s(literal -2 binary64)) im))))
(/.f64 (fma.f64 (/.f64 re im) (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -8 binary64)) (+.f64 #s(literal 4 binary64) (-.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (/.f64 (*.f64 re #s(literal -2 binary64)) im))))
(/.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -4 binary64)) (+.f64 (/.f64 re im) #s(literal 2 binary64)))
(/.f64 (neg.f64 (fma.f64 (/.f64 re im) (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -8 binary64))) (neg.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 4 binary64) (/.f64 (*.f64 re #s(literal -2 binary64)) im)))))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -4 binary64))) (neg.f64 (+.f64 (/.f64 re im) #s(literal 2 binary64))))
(/.f64 (-.f64 #s(literal 4 binary64) (/.f64 (*.f64 re re) (*.f64 im im))) (-.f64 #s(literal -2 binary64) (/.f64 re im)))
(*.f64 (fma.f64 (/.f64 re im) (/.f64 (*.f64 re re) (*.f64 im im)) #s(literal -8 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 #s(literal 4 binary64) (/.f64 (*.f64 re #s(literal -2 binary64)) im)))))
(*.f64 (+.f64 (/.f64 (*.f64 re re) (*.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 #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))
(*.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 #s(literal 1/2 binary64)) #s(literal 1/2 binary64)))
(sqrt.f64 #s(literal 1/2 binary64))
(pow.f64 #s(literal 1/2 binary64) #s(literal 1/2 binary64))
(*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1/2 binary64)))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(/.f64 #s(literal 1 binary64) (sqrt.f64 re))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 re)))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (-.f64 #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 (sqrt.f64 re) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/4 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal -1 binary64)))
(neg.f64 (/.f64 #s(literal -1 binary64) re))
(/.f64 #s(literal 1 binary64) re)
(/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) re))
(pow.f64 re #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)))
(+.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) re)))
(+.f64 (*.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 2 binary64)) (*.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 2 binary64)))
(fma.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 2 binary64) (*.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 2 binary64)))
(fma.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) re)))
(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 (*.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) (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 re re))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (-.f64 (*.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 (-.f64 (fma.f64 im im (*.f64 re re)) (*.f64 re re)) #s(literal 2 binary64)) (+.f64 re (sqrt.f64 (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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) #s(literal 2 binary64))
(*.f64 im (sqrt.f64 #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)
(*.f64 im #s(literal 1 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im (sqrt.f64 #s(literal 2 binary64))))
(*.f64 #s(literal 1 binary64) im)
(*.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 #s(literal 1/2 binary64)))
(/.f64 (*.f64 im #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 (*.f64 im #s(literal 1 binary64)) #s(literal 1 binary64)) (sqrt.f64 re))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 im #s(literal 1 binary64))) (sqrt.f64 re))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)))
(*.f64 #s(literal 1 binary64) (*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im #s(literal 1 binary64)))
(*.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 im #s(literal 1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 2 binary64))) (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64)) im)

simplify688.0ms (7.3%)

Memory
-31.6MiB live, 664.3MiB allocated
Algorithm
1×egg-herbie
Rules
10 082×accelerator-lowering-fma.f32
10 082×accelerator-lowering-fma.f64
7 874×*-lowering-*.f32
7 874×*-lowering-*.f64
4 824×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

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

eval110.0ms (1.2%)

Memory
12.5MiB live, 88.1MiB allocated
Compiler

Compiled 10 217 to 1 542 computations (84.9% saved)

prune90.0ms (1%)

Memory
-3.4MiB live, 72.9MiB allocated
Pruning

16 alts after pruning (13 fresh and 3 done)

PrunedKeptTotal
New5408548
Fresh5510
Picked235
Done000
Total54716563
Accuracy
99.9%
Counts
563 → 16
Alt Table
Click to see full alt table
StatusAccuracyProgram
42.7%
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (sqrt.f64 #s(literal 2 binary64)))
50.3%
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
▶42.9%
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
27.4%
(*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im #s(literal 1 binary64)) (sqrt.f64 re)))
27.2%
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
27.4%
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64)) im))
▶27.2%
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (/.f64 #s(literal 1 binary64) (sqrt.f64 re))))
27.2%
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/4 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/4 binary64)))))
✓50.3%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))))
▶14.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 im im) re)))
13.5%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 #s(literal 1 binary64) re)))))
26.9%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
✓50.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
✓77.5%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re))))
▶52.7%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re))))
▶5.3%
#s(literal 0 binary64)
Compiler

Compiled 377 to 279 computations (26% saved)

simplify333.0ms (3.5%)

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

Found 16 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(/.f64 #s(literal 1 binary64) (sqrt.f64 re))
✓cost-diff0
(sqrt.f64 #s(literal 1/2 binary64))
✓cost-diff0
(sqrt.f64 #s(literal 2 binary64))
✓cost-diff320
(*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (/.f64 #s(literal 1 binary64) (sqrt.f64 re)))
✓cost-diff0
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓cost-diff0
(-.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 (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
✓cost-diff-64
(*.f64 im im)
✓cost-diff0
(/.f64 (*.f64 im im) re)
✓cost-diff0
(sqrt.f64 (/.f64 (*.f64 im im) re))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 im im) 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
2 560×accelerator-lowering-fma.f32
2 560×accelerator-lowering-fma.f64
2 332×*-lowering-*.f32
2 332×*-lowering-*.f64
1 760×div-sub
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
029176
153172
2122172
3341172
4659172
5832172
61093172
71294172
82196172
93325172
103965172
114462172
125085172
135556172
146148172
157222172
167582172
177582172
187582172
197582172
207588172
217592172
227592172
237596172
07596146
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
0
(* 1/2 (sqrt (/ (* im im) re)))
1/2
(sqrt (/ (* im im) re))
(/ (* im im) re)
(* im im)
im
re
(* (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
1/2
(* 1/2 (* (* (sqrt 2) (* (sqrt 1/2) im)) (/ 1 (sqrt re))))
1/2
(* (* (sqrt 2) (* (sqrt 1/2) im)) (/ 1 (sqrt re)))
(* (sqrt 2) (* (sqrt 1/2) im))
(sqrt 2)
2
(* (sqrt 1/2) im)
(sqrt 1/2)
im
(/ 1 (sqrt re))
1
(sqrt re)
re
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
0
#s(literal 0 binary64)
(* 1/2 (sqrt (/ (* im im) re)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (fma.f64 im im #s(literal 0 binary64)) re)))
1/2
#s(literal 1/2 binary64)
(sqrt (/ (* im im) re))
(sqrt.f64 (/.f64 (fma.f64 im im #s(literal 0 binary64)) re))
(/ (* im im) re)
(/.f64 (fma.f64 im im #s(literal 0 binary64)) re)
(* im im)
(fma.f64 im im #s(literal 0 binary64))
im
re
(* (sqrt (* 2 (- (sqrt (+ (* im im) (* re re))) re))) 1/2)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (fma.f64 re re #s(literal 0 binary64)))) re) #s(literal 0 binary64))))
(sqrt (* 2 (- (sqrt (+ (* im im) (* re re))) re)))
(sqrt.f64 (fma.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (fma.f64 re re #s(literal 0 binary64)))) re) #s(literal 0 binary64)))
(* 2 (- (sqrt (+ (* im im) (* re re))) re))
(fma.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (fma.f64 re re #s(literal 0 binary64)))) re) #s(literal 0 binary64))
2
#s(literal 2 binary64)
(- (sqrt (+ (* im im) (* re re))) re)
(-.f64 (sqrt.f64 (fma.f64 im im (fma.f64 re re #s(literal 0 binary64)))) re)
(sqrt (+ (* im im) (* re re)))
(sqrt.f64 (fma.f64 im im (fma.f64 re re #s(literal 0 binary64))))
(+ (* im im) (* re re))
(fma.f64 im im (fma.f64 re re #s(literal 0 binary64)))
im
(* re re)
(fma.f64 re re #s(literal 0 binary64))
re
1/2
#s(literal 1/2 binary64)
(* 1/2 (* (* (sqrt 2) (* (sqrt 1/2) im)) (/ 1 (sqrt re))))
(fma.f64 (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 im (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) #s(literal 0 binary64))
1/2
#s(literal 1/2 binary64)
(* (* (sqrt 2) (* (sqrt 1/2) im)) (/ 1 (sqrt re)))
(fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 im (sqrt.f64 re)) #s(literal 0 binary64)) #s(literal 0 binary64))
(* (sqrt 2) (* (sqrt 1/2) im))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (fma.f64 im (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 0 binary64)) #s(literal 0 binary64))
(sqrt 2)
(sqrt.f64 #s(literal 2 binary64))
2
#s(literal 2 binary64)
(* (sqrt 1/2) im)
(fma.f64 im (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 0 binary64))
(sqrt 1/2)
(sqrt.f64 #s(literal 1/2 binary64))
im
(/ 1 (sqrt re))
(/.f64 #s(literal 1 binary64) (sqrt.f64 re))
1
#s(literal 1 binary64)
(sqrt re)
(sqrt.f64 re)
re

localize187.0ms (2%)

Memory
-28.8MiB live, 127.7MiB allocated
Localize:

Found 16 expressions of interest:

NewMetricScoreProgram
✓accuracy99.9%
(*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (/.f64 #s(literal 1 binary64) (sqrt.f64 re)))
✓accuracy99.9%
(/.f64 #s(literal 1 binary64) (sqrt.f64 re))
✓accuracy99.9%
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im))
✓accuracy99.8%
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)
✓accuracy100.0%
(*.f64 re re)
✓accuracy100.0%
(*.f64 #s(literal 2 binary64) (-.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)))
✓accuracy93.8%
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓accuracy100.0%
(*.f64 im im)
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 im im) re)))
✓accuracy97.1%
(/.f64 (*.f64 im im) re)
✓accuracy94.9%
(sqrt.f64 (/.f64 (*.f64 im im) 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
73.0ms200×0invalid
23.0ms56×0valid
Compiler

Compiled 172 to 31 computations (82% saved)

Precisions
Click to see histograms. Total time spent on operations: 61.0ms
ival-mult: 43.0ms (70% of total)
ival-sqrt: 10.0ms (16.3% of total)
ival-sub: 3.0ms (4.9% of total)
ival-div: 3.0ms (4.9% of total)
ival-add: 1.0ms (1.6% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series61.0ms (0.6%)

Memory
8.5MiB live, 46.9MiB allocated
Counts
20 → 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 (* 1/2 (sqrt (/ (* im im) re)))>
#<alt (sqrt (/ (* im im) re))>
#<alt (/ (* im im) re)>
#<alt (* im im)>
#<alt (* (sqrt (* 2 (- (sqrt (+ (* im im) (* re re))) re))) 1/2)>
#<alt (sqrt (* 2 (- (sqrt (+ (* im im) (* re re))) re)))>
#<alt (- (sqrt (+ (* im im) (* re re))) re)>
#<alt (sqrt (+ (* im im) (* re re)))>
#<alt (* (* (sqrt 2) (* (sqrt 1/2) im)) (/ 1 (sqrt re)))>
#<alt (sqrt 2)>
#<alt (sqrt 1/2)>
#<alt (/ 1 (sqrt re))>
#<alt (* 2 (- (sqrt (+ (* im im) (* re re))) re))>
#<alt (* re re)>
#<alt (* (sqrt 1/2) im)>
#<alt (* (sqrt 2) (* (sqrt 1/2) im))>
Outputs
#<alt (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2))))>
#<alt (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2)))))>
#<alt (+ (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2)))) (* im (+ (* -1/16 (* (/ (* im (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (/ (sqrt 2) (sqrt -1)))))))>
#<alt (+ (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2)))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (/ (sqrt 2) (sqrt -1)))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (/ (sqrt 2) (pow (sqrt -1) 3)))) (* 1/32 (* (/ (* im (sqrt 2)) (pow (sqrt -1) 5)) (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/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -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/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))>
#<alt (* -1/2 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -2) (sqrt -1))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))))))>
#<alt (* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -2) (sqrt -1))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -2) (sqrt -1))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))))))))>
#<alt (* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -2) (sqrt -1))))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (* (sqrt -2) (sqrt -1))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -2) (sqrt -1))))) (* 1/2 (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))))))))>
#<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/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* -1/16 (* (sqrt (/ 1 (pow im 3))) (* re (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 -1) (sqrt 2))))>
#<alt (* re (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))>
#<alt (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))))>
#<alt (* -1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2))))>
#<alt (* -1 (* re (+ (* 1/4 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* -1 (* re (+ (* -1/16 (* (* (pow im 2) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))))>
#<alt (* -1 (* re (+ (* -1/16 (* (* (pow im 2) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))))>
#<alt (* (sqrt re) (* (sqrt -1) (sqrt 2)))>
#<alt (+ (* 1/2 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 re)))) (* (sqrt re) (* (sqrt -1) (sqrt 2))))>
#<alt (+ (* im (+ (* -1/8 (* (/ (* im (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (/ (sqrt 2) (sqrt -1)))))) (* (sqrt re) (* (sqrt -1) (sqrt 2))))>
#<alt (+ (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (/ (sqrt 2) (sqrt -1)))) (* im (+ (* -1/8 (* (sqrt (/ 1 (pow re 3))) (/ (sqrt 2) (pow (sqrt -1) 3)))) (* 1/16 (* (/ (* im (sqrt 2)) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 5))))))))) (* (sqrt re) (* (sqrt -1) (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/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* -1/16 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* -1 (* (sqrt im) (* (sqrt -2) (sqrt -1))))>
#<alt (* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -2) (sqrt -1))))) (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -2) (sqrt -1))))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -2) (sqrt -1))))) (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1)))))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (sqrt -2) (sqrt -1))))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (* (sqrt -2) (sqrt -1))))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -2) (sqrt -1))))) (* (sqrt (/ 1 im)) (* (sqrt -2) (sqrt -1))))))))>
#<alt (* (sqrt im) (sqrt 2))>
#<alt (+ (* -1/2 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* (sqrt im) (sqrt 2)))>
#<alt (+ (* re (+ (* -1/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* -1/8 (* (sqrt (/ 1 (pow im 3))) (* re (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 -1) (sqrt 2)))>
#<alt (* re (+ (* 1/2 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))>
#<alt (* re (+ (* -1/8 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))>
#<alt (* re (+ (* -1/8 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* -1 (* (sqrt re) (* (sqrt -1) (sqrt 2))))>
#<alt (* -1 (* re (+ (* 1/2 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))>
#<alt (* -1 (* re (+ (* -1/8 (* (* (pow im 2) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))>
#<alt (* -1 (* re (+ (* -1/8 (* (* (pow im 2) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))))>
#<alt (* -1 re)>
#<alt (- im re)>
#<alt (- im re)>
#<alt (- im re)>
#<alt im>
#<alt (* im (+ 1 (* -1 (/ re im))))>
#<alt (* im (+ 1 (* -1 (/ re im))))>
#<alt (* im (+ 1 (* -1 (/ re im))))>
#<alt im>
#<alt (* -1 (* im (- (/ re im) 1)))>
#<alt (* -1 (* im (- (/ re im) 1)))>
#<alt (* -1 (* im (- (/ re im) 1)))>
#<alt im>
#<alt (+ im (* -1 re))>
#<alt (+ im (* -1 re))>
#<alt (+ im (* -1 re))>
#<alt (* -1 re)>
#<alt (* re (- (/ im re) 1))>
#<alt (* re (- (/ im re) 1))>
#<alt (* re (- (/ im re) 1))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* -1 (/ im re)))))>
#<alt (* -1 (* re (+ 1 (* -1 (/ im re)))))>
#<alt (* -1 (* re (+ 1 (* -1 (/ im re)))))>
#<alt (* -2 re)>
#<alt (+ (* -2 re) (* 2 im))>
#<alt (+ (* -2 re) (* 2 im))>
#<alt (+ (* -2 re) (* 2 im))>
#<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 re) (* 2 im))>
#<alt (+ (* -2 re) (* 2 im))>
#<alt (+ (* -2 re) (* 2 im))>
#<alt (* -2 re)>
#<alt (* re (- (* 2 (/ im re)) 2))>
#<alt (* re (- (* 2 (/ im re)) 2))>
#<alt (* re (- (* 2 (/ im re)) 2))>
#<alt (* -2 re)>
#<alt (* -1 (* re (+ 2 (* -2 (/ im re)))))>
#<alt (* -1 (* re (+ 2 (* -2 (/ im re)))))>
#<alt (* -1 (* re (+ 2 (* -2 (/ im re)))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* -1/2 (* im (sqrt (/ 1 re))))>
#<alt (* -1/2 (* im (sqrt (/ 1 re))))>
#<alt (* -1/2 (* im (sqrt (/ 1 re))))>
#<alt (* -1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* im (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))>
#<alt (* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* -1 (* im (sqrt (/ 1 re))))>
#<alt (* -1 (* im (sqrt (/ 1 re))))>
#<alt (* -1 (* im (sqrt (/ 1 re))))>
#<alt (* -1 (* im (sqrt (/ 1 re))))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* im (sqrt (/ 1 re)))>
#<alt (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re)))>
#<alt (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re)))>
#<alt (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re)))>
#<alt (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 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 (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 (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))>
#<alt (* im (+ (* -1/32 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))))))>
#<alt (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/4 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re)))))))>
#<alt (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))) (* (pow im 2) (+ (* -1/32 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/4 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/4 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/2))))))))))>
#<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/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))>
#<alt (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -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/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/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (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/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/16 (* (sqrt (/ 1 (pow im 3))) (* re (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 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))>
#<alt (+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))>
#<alt (+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))))>
#<alt (+ (* -1/32 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/1024 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/64 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* 1/2 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))))>
#<alt (* -1/2 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2))))>
#<alt (* -1 (* re (+ (* -1/8 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/32 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/64 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/8 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2)))))))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* im (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2)))))>
#<alt (* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt re)))))))>
#<alt (* im (+ (* (sqrt (/ 1 re)) (* (sqrt 1/2) (sqrt 2))) (* (pow im 2) (+ (* -1/16 (* (sqrt (/ 1 (pow re 5))) (/ (sqrt 2) (sqrt 1/2)))) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (* (sqrt 2) (+ (* -1/16 (/ (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2))))) (* (pow re 2) (pow (sqrt 1/2) 2)))) (* 5/128 (/ 1 (pow re 7)))))) (sqrt 1/2)) (sqrt re))) (* 1/2 (* (sqrt re) (/ (* (sqrt 2) (- (* 1/16 (/ 1 (pow re 5))) (* 1/256 (/ 1 (* (pow re 5) (pow (sqrt 1/2) 2)))))) (sqrt 1/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/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2)))))>
#<alt (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (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/2 (* (sqrt (/ 1 (pow im 3))) (* re (* (sqrt -1) (sqrt 2))))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (* (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/2 (* (sqrt (/ 1 im)) (sqrt 2))) (* 1/8 (* (sqrt (/ 1 (pow im 3))) (* re (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 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))>
#<alt (+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))))>
#<alt (+ (* -1/16 (* (/ (* (pow im 3) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/512 (* (/ (* (pow im 5) (sqrt 2)) (pow (sqrt 1/2) 3)) (sqrt (/ 1 (pow re 9))))) (+ (* 1/32 (* (/ (* (pow im 5) (sqrt 2)) (sqrt 1/2)) (sqrt (/ 1 (pow re 9))))) (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re))))))>
#<alt (* -1 (* (sqrt re) (* (sqrt -1) (pow (sqrt 2) 2))))>
#<alt (* -1 (* re (+ (* -1/4 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re)))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* -1/16 (* (* (pow im 4) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (+ (* 1/32 (* (/ (* (pow im 4) (sqrt -1)) (pow (sqrt 2) 2)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (* (pow im 2) (sqrt -1)) (sqrt re))))) (pow re 3))) (* (sqrt (/ 1 re)) (* (sqrt -1) (pow (sqrt 2) 2))))))>
#<alt (* 1/2 (/ (pow im 2) re))>
#<alt (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))>
#<alt (* (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 (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/128 (/ (pow im 2) (pow re 7))) (* 1/16 (/ 1 (pow re 5))))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))>
#<alt im>
#<alt (* im (+ 1 (* -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 (/ re im))))>
#<alt (* -1 (* im (+ 1 (* -1 (/ (- (* -1/2 (/ (pow re 2) im)) re) im)))))>
#<alt (* -1 (* im (+ 1 (* -1 (/ (- (* -1 (/ (+ (* -1/8 (/ (pow re 4) (pow im 2))) (* 1/2 (pow re 2))) im)) re) im)))))>
#<alt im>
#<alt (+ im (* -1 re))>
#<alt (+ im (* re (- (* 1/2 (/ re im)) 1)))>
#<alt (+ im (* re (- (* re (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))) 1)))>
#<alt (* 1/2 (/ (pow im 2) re))>
#<alt (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (* 1/2 (pow im 2))) re)>
#<alt (/ (+ (* -1/8 (/ (pow im 4) (pow re 2))) (+ (* 1/16 (/ (pow im 6) (pow re 4))) (* 1/2 (pow im 2)))) re)>
#<alt (/ (+ (* -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 (* re (+ 2 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 2 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* 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 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 (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (* (* im (* (sqrt 1/2) (sqrt 2))) (sqrt (/ 1 re)))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (sqrt (/ 1 re))>
#<alt (/ (pow im 2) re)>
#<alt (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 3))) (/ 1 re)))>
#<alt (* (pow im 2) (+ (* (pow im 2) (- (* 1/8 (/ (pow im 2) (pow re 5))) (* 1/4 (/ 1 (pow re 3))))) (/ 1 re)))>
#<alt (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* -5/64 (/ (pow im 2) (pow re 7))) (* 1/8 (/ 1 (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 (+ (* -2 (/ re im)) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))>
#<alt (* -2 im)>
#<alt (* -1 (* im (+ 2 (* 2 (/ re im)))))>
#<alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (pow re 2) im))) im)))))>
#<alt (* -1 (* im (+ 2 (* -1 (/ (+ (* -2 re) (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow im 2))) (pow re 2)) im))) im)))))>
#<alt (* 2 im)>
#<alt (+ (* -2 re) (* 2 im))>
#<alt (+ (* 2 im) (* re (- (/ re im) 2)))>
#<alt (+ (* 2 im) (* re (- (* re (+ (* -1/4 (/ (pow re 2) (pow im 3))) (/ 1 im))) 2)))>
#<alt (/ (pow im 2) re)>
#<alt (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (pow im 2)) re)>
#<alt (/ (+ (* -1/4 (/ (pow im 4) (pow re 2))) (+ (* 1/8 (/ (pow im 6) (pow re 4))) (pow im 2))) re)>
#<alt (/ (+ (* -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 (* -1 (* re (+ 4 (/ (pow im 2) (pow re 2)))))>
#<alt (* -1 (* re (+ 4 (+ (* -1/4 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* 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 (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (sqrt 1/2))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
#<alt (* im (* (sqrt 1/2) (sqrt 2)))>
Calls

93 calls:

TimeVariablePointExpression
34.0ms
re
@-inf
(/ 1 (sqrt re))
5.0ms
im
@inf
(* 1/2 (sqrt (/ (* im im) re)))
2.0ms
im
@inf
(sqrt (* 2 (- im re)))
1.0ms
re
@inf
(* 1/2 (sqrt (* 2 (- im re))))
1.0ms
im
@-inf
(* 1/2 (sqrt (* 2 (- im re))))

rewrite614.0ms (6.5%)

Memory
14.3MiB live, 646.9MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 262×accelerator-lowering-fma.f32
5 262×accelerator-lowering-fma.f64
4 296×*-lowering-*.f32
4 296×*-lowering-*.f64
2 892×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
027130
1111122
2695117
36513117
0833792
Stop Event
1×iter limit
1×node limit
Counts
20 → 653
Calls
Call 1
Inputs
(* 1/2 (sqrt (* 2 (- im re))))
(sqrt (* 2 (- im re)))
(- im re)
(* 2 (- im re))
(* 1/2 (sqrt (/ (* im im) re)))
(sqrt (/ (* im im) re))
(/ (* im im) re)
(* im im)
(* (sqrt (* 2 (- (sqrt (+ (* im im) (* re re))) re))) 1/2)
(sqrt (* 2 (- (sqrt (+ (* im im) (* re re))) re)))
(- (sqrt (+ (* im im) (* re re))) re)
(sqrt (+ (* im im) (* re re)))
(* (* (sqrt 2) (* (sqrt 1/2) im)) (/ 1 (sqrt re)))
(sqrt 2)
(sqrt 1/2)
(/ 1 (sqrt re))
(* 2 (- (sqrt (+ (* im im) (* re re))) re))
(* re re)
(* (sqrt 1/2) im)
(* (sqrt 2) (* (sqrt 1/2) im))
Outputs
(/.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 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.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 #s(literal 1/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 (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 #s(literal 2 binary64) (-.f64 im re)) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)) #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 im re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (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)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))))
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))
(/.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (sqrt.f64 (+.f64 im re)))
(/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re)))) (sqrt.f64 (+.f64 im re)))
(/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re))) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (+.f64 im re)))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im im))))
(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 #s(literal 2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)) (sqrt.f64 (-.f64 im re))))
(*.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 (*.f64 (sqrt.f64 (-.f64 im re)) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64))) (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64)))
(+.f64 im (-.f64 #s(literal 0 binary64) re))
(+.f64 (-.f64 #s(literal 0 binary64) re) im)
(+.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(+.f64 (/.f64 (*.f64 im im) (+.f64 im re)) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(-.f64 im re)
(-.f64 #s(literal 0 binary64) (-.f64 re im))
(-.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(-.f64 (/.f64 (*.f64 im im) (+.f64 im re)) (*.f64 re (/.f64 re (+.f64 im re))))
(-.f64 (+.f64 im #s(literal 0 binary64)) re)
(fma.f64 im #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))
(fma.f64 im (/.f64 im (+.f64 im re)) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(fma.f64 im (/.f64 (*.f64 im im) (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 re #s(literal -1 binary64) im)
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) (+.f64 im re)) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(fma.f64 (*.f64 im im) (/.f64 im (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) re))
(fma.f64 #s(literal 1 binary64) im (-.f64 #s(literal 0 binary64) re))
(fma.f64 #s(literal -1 binary64) re im)
(fma.f64 (*.f64 im (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 (sqrt.f64 im) (sqrt.f64 im) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 im (sqrt.f64 #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) re))
(fma.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 im (sqrt.f64 #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (pow.f64 im #s(literal 3/2 binary64)) (/.f64 (pow.f64 im #s(literal 3/2 binary64)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (pow.f64 (*.f64 im im) #s(literal 1/4 binary64)) (pow.f64 (*.f64 im im) #s(literal 1/4 binary64)) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (*.f64 (*.f64 im (sqrt.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 #s(literal 0 binary64) re))
(fma.f64 (*.f64 #s(literal 1 binary64) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (*.f64 #s(literal 1 binary64) (*.f64 im (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (/.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re))) (-.f64 im re) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im im) (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im)))) (fma.f64 re (-.f64 re im) (*.f64 im im)) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (*.f64 (+.f64 im re) (*.f64 re (+.f64 im re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re (+.f64 im re)) (-.f64 (*.f64 re (+.f64 im re)) (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im)))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))))) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(neg.f64 (/.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (-.f64 #s(literal 0 binary64) (+.f64 im re))))
(neg.f64 (/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re))) (+.f64 im re)))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 im re)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im)) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re))))
(/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 re (+.f64 im re) (*.f64 im im)))
(/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im)))
(/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 re re (-.f64 (*.f64 im im) (*.f64 im (-.f64 #s(literal 0 binary64) re)))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re))) (*.f64 (+.f64 im re) (fma.f64 im im (*.f64 re re))))
(/.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (+.f64 im re))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re))) (-.f64 #s(literal 0 binary64) (+.f64 im re)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (neg.f64 (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (*.f64 (+.f64 im re) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (-.f64 (-.f64 #s(literal 0 binary64) re) im))
(/.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (+.f64 im re)) (*.f64 (+.f64 im re) (*.f64 re re))) (*.f64 (+.f64 im re) (+.f64 im re)))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))))) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 im im (*.f64 re 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 (fma.f64 im im (*.f64 re re)) (+.f64 im re)))
(/.f64 (*.f64 (*.f64 (-.f64 im re) (+.f64 im re)) #s(literal 1 binary64)) (+.f64 im re))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re)))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 im re))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (*.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 im im) (+.f64 im re)) #s(literal 3 binary64)) (pow.f64 (*.f64 re (/.f64 re (+.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 re (/.f64 re (+.f64 im re))) (*.f64 re (/.f64 re (+.f64 im re))) (*.f64 (/.f64 (*.f64 im im) (+.f64 im re)) (*.f64 re (/.f64 re (+.f64 im re)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (fma.f64 im (/.f64 (*.f64 im im) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 im im) (+.f64 im re)) (/.f64 (*.f64 im im) (+.f64 im re))) (*.f64 (*.f64 re (/.f64 re (+.f64 im re))) (*.f64 re (/.f64 re (+.f64 im re))))) (fma.f64 im (/.f64 im (+.f64 im re)) (*.f64 re (/.f64 re (+.f64 im re)))))
(/.f64 (*.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) #s(literal 1 binary64)) (fma.f64 re (+.f64 im re) (*.f64 im im)))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (fma.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re))) (/.f64 #s(literal 1 binary64) (+.f64 im re))) (fma.f64 im im (*.f64 re re)))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (+.f64 im re))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (-.f64 im re))
(*.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im))))
(*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (*.f64 (-.f64 im re) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (/.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (+.f64 im re)))
(*.f64 (+.f64 im re) (*.f64 (-.f64 im re) (/.f64 #s(literal 1 binary64) (+.f64 im re))))
(*.f64 (+.f64 im re) (/.f64 (-.f64 im re) (+.f64 im re)))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 im re))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re)) (*.f64 (-.f64 im re) (+.f64 im re)))
(*.f64 (/.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 (-.f64 im re) (+.f64 im re))) (-.f64 im re))
(*.f64 (/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (*.f64 (+.f64 im re) (*.f64 re (+.f64 im re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re (+.f64 im re)) (-.f64 (*.f64 re (+.f64 im re)) (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(*.f64 (/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))))) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))))
(*.f64 (/.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im)))) (fma.f64 re (-.f64 re im) (*.f64 im 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))
(fma.f64 #s(literal 2 binary64) im (*.f64 #s(literal -2 binary64) re))
(fma.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) re) (*.f64 #s(literal 2 binary64) im))
(fma.f64 im #s(literal 2 binary64) (*.f64 #s(literal -2 binary64) re))
(fma.f64 #s(literal -1 binary64) (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) im))
(fma.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) im))
(fma.f64 #s(literal -2 binary64) re (*.f64 #s(literal 2 binary64) im))
(/.f64 #s(literal 2 binary64) (/.f64 #s(literal 1 binary64) (-.f64 im re)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 im re) (*.f64 (+.f64 im re) (*.f64 #s(literal 2 binary64) (-.f64 im re)))))
(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (fma.f64 re (+.f64 im re) (*.f64 im im)))
(/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im)))
(/.f64 (*.f64 (+.f64 im re) (*.f64 #s(literal 2 binary64) (-.f64 im re))) (+.f64 im re))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (neg.f64 (*.f64 (+.f64 im re) (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (-.f64 #s(literal 0 binary64) (+.f64 im re)))
(/.f64 (+.f64 (pow.f64 (*.f64 #s(literal 2 binary64) im) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal -2 binary64) re) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) im) (-.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 #s(literal 2 binary64) im) (*.f64 #s(literal 2 binary64) im)) (*.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) (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re)))) (-.f64 #s(literal 0 binary64) (+.f64 im re)))
(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (+.f64 im re)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.f64 #s(literal 2 binary64) (-.f64 im re))
(*.f64 (-.f64 im re) #s(literal 2 binary64))
(*.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))) #s(literal 2 binary64)))
(*.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 #s(literal 2 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re)) #s(literal 2 binary64)))
(*.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (/.f64 #s(literal 2 binary64) (+.f64 im re)))
(*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.f64 (*.f64 (+.f64 im re) (*.f64 #s(literal 2 binary64) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (+.f64 im re)))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 re (*.f64 (+.f64 im re) (*.f64 re (+.f64 im re)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re (+.f64 im re)) (-.f64 (*.f64 re (+.f64 im re)) (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))))) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))))
(*.f64 (/.f64 (*.f64 (+.f64 im re) (*.f64 #s(literal 2 binary64) (-.f64 im re))) (*.f64 (-.f64 im re) (+.f64 im re))) (-.f64 im re))
(*.f64 (/.f64 (*.f64 (+.f64 im re) (*.f64 #s(literal 2 binary64) (-.f64 im re))) (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im)))) (fma.f64 re (-.f64 re im) (*.f64 im im)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 re))) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) im)))
(/.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 re))
(/.f64 (neg.f64 (*.f64 #s(literal 1/2 binary64) im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (*.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 im (*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 re)) #s(literal 1/2 binary64)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 re))) #s(literal 1 binary64))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 (/.f64 im re)) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 im (pow.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (/.f64 im #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 im (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 (/.f64 im re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64)))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))) #s(literal -1 binary64))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re))))
(sqrt.f64 (/.f64 (*.f64 im im) re))
(neg.f64 (*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)) im))
(neg.f64 (*.f64 im (/.f64 #s(literal -1 binary64) (sqrt.f64 re))))
(neg.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)))
(/.f64 im (sqrt.f64 re))
(/.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (sqrt.f64 re) im)))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 re (-.f64 #s(literal 0 binary64) (*.f64 im im)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 re))
(/.f64 (neg.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (neg.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(/.f64 (/.f64 im (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (sqrt.f64 re))
(pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(pow.f64 (/.f64 re (*.f64 im im)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 (sqrt.f64 re) im) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (/.f64 (*.f64 im im) re))) #s(literal 1/2 binary64))
(*.f64 im (/.f64 #s(literal 1 binary64) (sqrt.f64 re)))
(*.f64 im (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 2 binary64) re))))
(*.f64 im (*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im (sqrt.f64 (/.f64 #s(literal 2 binary64) re))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (sqrt.f64 re))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 re)))
(*.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 2 binary64) re)))
(*.f64 #s(literal 1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 re)) (/.f64 im #s(literal 1 binary64)))
(*.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)) im))
(*.f64 #s(literal -1 binary64) (/.f64 im (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)) (/.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 im) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 im))
(*.f64 (sqrt.f64 (/.f64 im re)) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)))
(*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal 1/2 binary64)))
(*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (sqrt.f64 (/.f64 #s(literal -1 binary64) re)))
(*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (pow.f64 re #s(literal -1/4 binary64)) (*.f64 (pow.f64 re #s(literal -1/4 binary64)) im))
(*.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 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re))))
(*.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64)))
(*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 2 binary64) re)) (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 2 binary64) re)) (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 im (pow.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 im (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 re)) (*.f64 im (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 re)) (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 (sqrt.f64 im) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 im) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (*.f64 (sqrt.f64 im) (pow.f64 re #s(literal -1/4 binary64))) (*.f64 (sqrt.f64 im) (pow.f64 re #s(literal -1/4 binary64))))
(*.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (sqrt.f64 re))) #s(literal -1 binary64))
(*.f64 (*.f64 im (pow.f64 re #s(literal -1/4 binary64))) (pow.f64 re #s(literal -1/4 binary64)))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 re)) (*.f64 im (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 #s(literal 1/2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 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 (sqrt.f64 (/.f64 #s(literal 2 binary64) re)) im) (sqrt.f64 #s(literal 1/2 binary64)))
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 2 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) im)
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 re)) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 re (*.f64 im im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) re))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) re)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) re))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) re))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) re)))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 re (*.f64 im im))))
(/.f64 im (/.f64 re im))
(/.f64 (*.f64 im im) re)
(/.f64 #s(literal 1 binary64) (/.f64 re (*.f64 im im)))
(/.f64 #s(literal -1 binary64) (/.f64 re (-.f64 #s(literal 0 binary64) (*.f64 im im))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (-.f64 #s(literal 0 binary64) re))
(/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) (*.f64 im im)))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (-.f64 #s(literal 0 binary64) re))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) re))
(/.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))
(*.f64 im (/.f64 im re))
(*.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 (*.f64 im im) re) #s(literal 1 binary64))
(*.f64 (/.f64 im (sqrt.f64 re)) (/.f64 im (sqrt.f64 re)))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 im im) re))
(*.f64 #s(literal -1 binary64) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) re))
(*.f64 (-.f64 #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 #s(literal 1 binary64) re) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 im im)) #s(literal -1 binary64)))
(*.f64 (/.f64 im re) im)
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 im (-.f64 #s(literal 0 binary64) re)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 im (/.f64 #s(literal -1 binary64) re)))
(*.f64 (/.f64 #s(literal -1 binary64) re) (-.f64 #s(literal 0 binary64) (*.f64 im im)))
(*.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) im) re))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (/.f64 im re))
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 #s(literal -1 binary64) re))
(exp.f64 (fma.f64 #s(literal 2 binary64) (log.f64 im) #s(literal 0 binary64)))
(fabs.f64 (*.f64 im im))
(-.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (*.f64 im im)))
(sqrt.f64 (*.f64 im (*.f64 im (*.f64 im im))))
(neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (*.f64 im (*.f64 im (*.f64 im im))) #s(literal 1/2 binary64))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 2 binary64))
(*.f64 im im)
(*.f64 im (neg.f64 (-.f64 #s(literal 0 binary64) im)))
(*.f64 (*.f64 im im) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 im im))
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 im im)))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.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 (neg.f64 (-.f64 #s(literal 0 binary64) im)) im)
(*.f64 (*.f64 im (sqrt.f64 im)) (sqrt.f64 im))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (-.f64 (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re 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 (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 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 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64))) (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))))
(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) (-.f64 (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (-.f64 (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (sqrt.f64 (-.f64 (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 binary64)) (pow.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1/4 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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(*.f64 (*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re 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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (-.f64 #s(literal 0 binary64) re))
(+.f64 (-.f64 #s(literal 0 binary64) re) (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (/.f64 (*.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)))) (neg.f64 (/.f64 (*.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 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (/.f64 (*.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 #s(literal 0 binary64) (-.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(-.f64 (/.f64 (*.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 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 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(-.f64 (+.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 0 binary64)) 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 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(fma.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (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)))) (neg.f64 (/.f64 (*.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))))))
(fma.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (/.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(fma.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (/.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)))) (neg.f64 (/.f64 (*.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))))))
(fma.f64 #s(literal -1 binary64) re (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(fma.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (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)))) (/.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)))) (neg.f64 (/.f64 (*.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))))))
(fma.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re))) (/.f64 (/.f64 #s(literal 1 binary64) (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(fma.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))) (-.f64 #s(literal 0 binary64) 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)) (-.f64 #s(literal 0 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)))) (-.f64 #s(literal 0 binary64) 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)))) (-.f64 #s(literal 0 binary64) 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)) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 3/4 binary64)) (/.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 3/4 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 (*.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))))))
(fma.f64 (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 re re (*.f64 (-.f64 im re) (+.f64 im re)))) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) (neg.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 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 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 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(fma.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (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 (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 (*.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 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (neg.f64 (/.f64 (*.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))))))
(fma.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (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 (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)))))) (neg.f64 (/.f64 (*.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 (*.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 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))) (-.f64 (*.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) (neg.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))))
(/.f64 (-.f64 (*.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 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re re))) (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (*.f64 re re))))
(/.f64 (-.f64 (*.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 re (-.f64 (fma.f64 im im (*.f64 re re)) (neg.f64 (*.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))))
(/.f64 (fma.f64 re re (*.f64 (-.f64 im re) (+.f64 im re))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.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) (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re re)))) (neg.f64 (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) 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 0 binary64) (+.f64 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 (*.f64 re 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 re (*.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 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 (*.f64 re re) (fma.f64 im im (fma.f64 re re (*.f64 re re))) (*.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)) (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 (*.f64 re 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 (*.f64 re (*.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 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 im im (fma.f64 re re (*.f64 re re))) (fma.f64 re re (*.f64 (-.f64 im re) (+.f64 im re)))) (*.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (fma.f64 im im (fma.f64 re re (*.f64 re re)))))
(/.f64 (-.f64 (*.f64 (*.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 (fma.f64 re (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (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))) (fma.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 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.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))))))
(/.f64 (*.f64 (-.f64 (*.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 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re (*.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 (fma.f64 im im (*.f64 re re)) (*.f64 (fma.f64 im im (*.f64 re re)) (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 (*.f64 re 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 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 (-.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 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re re) (fma.f64 im im (fma.f64 re re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im im (fma.f64 re re (*.f64 re re))) (fma.f64 re re (*.f64 (-.f64 im re) (+.f64 im re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 im im (fma.f64 re re (*.f64 re 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))) #s(literal 1 binary64)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.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 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.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)))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.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)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.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 (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)))) (fma.f64 (/.f64 (*.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 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 (*.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 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 (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 3 binary64))) (fma.f64 (/.f64 (fma.f64 im im (*.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 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))))
(/.f64 (-.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re))) (-.f64 (-.f64 #s(literal 0 binary64) re) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.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 (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 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 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)))))) (fma.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (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 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 (*.f64 (/.f64 (fma.f64 im im (*.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)))))) (*.f64 (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))) (+.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (/.f64 (*.f64 re re) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (*.f64 (-.f64 (*.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 (-.f64 (*.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 (*.f64 re 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 (*.f64 re (*.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 (fma.f64 im im (*.f64 re re)) (*.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 (*.f64 re 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 re (*.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 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (fma.f64 (*.f64 re re) (fma.f64 im im (fma.f64 re re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (*.f64 (fma.f64 im im (fma.f64 re re (*.f64 re re))) (fma.f64 re re (*.f64 (-.f64 im re) (+.f64 im re)))) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))) (fma.f64 im im (fma.f64 re re (*.f64 re re))))
(pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
(*.f64 (-.f64 (*.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 (*.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 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) 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 (sqrt.f64 (fma.f64 im im (*.f64 re 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 (sqrt.f64 (fma.f64 im im (*.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 (fma.f64 re re (*.f64 (-.f64 im re) (+.f64 im re))) (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))))
(*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.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 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.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)))) (-.f64 (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (fma.f64 re re (*.f64 (-.f64 im re) (+.f64 im 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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))
(*.f64 (/.f64 (-.f64 (*.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 (*.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 (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)) (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 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))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(hypot.f64 im re)
(hypot.f64 im (-.f64 #s(literal 0 binary64) re))
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 re im)
(hypot.f64 re (-.f64 #s(literal 0 binary64) im))
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 (-.f64 #s(literal 0 binary64) re) im)
(hypot.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 #s(literal 0 binary64) im))
(hypot.f64 (-.f64 #s(literal 0 binary64) re) (exp.f64 (log.f64 im)))
(hypot.f64 (-.f64 #s(literal 0 binary64) im) re)
(hypot.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) re))
(hypot.f64 (-.f64 #s(literal 0 binary64) im) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 im)) (-.f64 #s(literal 0 binary64) re))
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 re)) (-.f64 #s(literal 0 binary64) im))
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(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 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 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 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re)))) (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 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 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re)))))
(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 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 im re) (+.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (-.f64 im re) (+.f64 im re)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re)))))
(*.f64 (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)))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (*.f64 im im) re))))
(sqrt.f64 (/.f64 (*.f64 im im) re))
(neg.f64 (*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)) im))
(neg.f64 (*.f64 im (/.f64 #s(literal -1 binary64) (sqrt.f64 re))))
(neg.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)))
(/.f64 im (sqrt.f64 re))
(/.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (sqrt.f64 re) im)))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 re (-.f64 #s(literal 0 binary64) (*.f64 im im)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 re))
(/.f64 (neg.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (neg.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(/.f64 (/.f64 im (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (sqrt.f64 re))
(pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(pow.f64 (/.f64 re (*.f64 im im)) #s(literal -1/2 binary64))
(pow.f64 (/.f64 (sqrt.f64 re) im) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (*.f64 im im) re) (/.f64 (*.f64 im im) re)) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (/.f64 (*.f64 im im) re))) #s(literal 1/2 binary64))
(*.f64 im (/.f64 #s(literal 1 binary64) (sqrt.f64 re)))
(*.f64 im (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 2 binary64) re))))
(*.f64 im (*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im (sqrt.f64 (/.f64 #s(literal 2 binary64) re))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (sqrt.f64 re))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 re)))
(*.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 2 binary64) re)))
(*.f64 #s(literal 1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 re)) (/.f64 im #s(literal 1 binary64)))
(*.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)) im))
(*.f64 #s(literal -1 binary64) (/.f64 im (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)) (/.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 im) (sqrt.f64 (/.f64 im re)))
(*.f64 (sqrt.f64 (/.f64 im re)) (sqrt.f64 im))
(*.f64 (sqrt.f64 (/.f64 im re)) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)))
(*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal 1/2 binary64)))
(*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (sqrt.f64 (/.f64 #s(literal -1 binary64) re)))
(*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (pow.f64 re #s(literal -1/4 binary64)) (*.f64 (pow.f64 re #s(literal -1/4 binary64)) im))
(*.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 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re))))
(*.f64 (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (*.f64 im im) re) #s(literal 1/4 binary64)))
(*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 2 binary64) re)) (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 2 binary64) re)) (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 im (pow.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 im (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 re)) (*.f64 im (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 re)) (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 im #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 im #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 (sqrt.f64 im) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 im) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (*.f64 (sqrt.f64 im) (pow.f64 re #s(literal -1/4 binary64))) (*.f64 (sqrt.f64 im) (pow.f64 re #s(literal -1/4 binary64))))
(*.f64 (/.f64 im (-.f64 #s(literal 0 binary64) (sqrt.f64 re))) #s(literal -1 binary64))
(*.f64 (*.f64 im (pow.f64 re #s(literal -1/4 binary64))) (pow.f64 re #s(literal -1/4 binary64)))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 re)) (*.f64 im (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 #s(literal 1/2 binary64)))
(*.f64 (*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 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 (sqrt.f64 (/.f64 #s(literal 2 binary64) re)) im) (sqrt.f64 #s(literal 1/2 binary64)))
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 2 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) im)
(*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 re)) (/.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 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 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (sqrt.f64 #s(literal 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)))
(*.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 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/2 binary64))))
(sqrt.f64 #s(literal 1/2 binary64))
(pow.f64 #s(literal 1/2 binary64) #s(literal 1/2 binary64))
(pow.f64 #s(literal 1/4 binary64) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 #s(literal 1/2 binary64))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 #s(literal -1 binary64) (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64))))
(exp.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64))))
(exp.f64 (*.f64 (log.f64 re) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 re)) #s(literal 1/2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(neg.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 re))
(/.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 re)) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(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 (pow.f64 re #s(literal -1/4 binary64)) #s(literal 2 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 re)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (pow.f64 re #s(literal -1/4 binary64)) (pow.f64 re #s(literal -1/4 binary64)))
(*.f64 (pow.f64 re #s(literal -1/4 binary64)) (*.f64 (pow.f64 re #s(literal -1/4 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)) #s(literal -1 binary64))
(*.f64 (pow.f64 (pow.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/4 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/4 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) (pow.f64 re #s(literal -1/4 binary64))) (pow.f64 re #s(literal -1/4 binary64)))
(+.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) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal -2 binary64) re))
(fma.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))) (*.f64 #s(literal -2 binary64) re))
(fma.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) re) (*.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 #s(literal -1 binary64) (*.f64 re #s(literal 2 binary64)) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(fma.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re 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 #s(literal -2 binary64) re (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re 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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) 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 #s(literal 2 binary64) (-.f64 (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 2 binary64) (fma.f64 re re (*.f64 (-.f64 im re) (+.f64 im re))))))
(/.f64 (*.f64 #s(literal 2 binary64) (-.f64 (*.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) (-.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 re (*.f64 re re)))) (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) 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 re (sqrt.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (-.f64 (*.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 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (+.f64 (pow.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal -2 binary64) re) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (-.f64 (*.f64 (*.f64 #s(literal -2 binary64) re) (*.f64 #s(literal -2 binary64) re)) (*.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal -2 binary64) re)))))
(/.f64 (-.f64 (*.f64 (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 2 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (*.f64 (*.f64 #s(literal -2 binary64) re) (*.f64 #s(literal -2 binary64) re))) (-.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) (-.f64 #s(literal 0 binary64) (-.f64 (*.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 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.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 #s(literal 0 binary64) (+.f64 re (sqrt.f64 (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 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re) #s(literal 2 binary64))
(*.f64 (-.f64 (*.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 (-.f64 (*.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 2 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 re (*.f64 (-.f64 im re) (+.f64 im re))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)))
(*.f64 (fma.f64 re re (*.f64 (-.f64 im re) (+.f64 im re))) (/.f64 #s(literal 2 binary64) (+.f64 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (*.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 re (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (-.f64 (*.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 (*.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 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))))
(*.f64 (/.f64 (*.f64 #s(literal 2 binary64) (-.f64 (*.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 (sqrt.f64 (fma.f64 im im (*.f64 re 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 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))))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 re)))
(neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 re re)))
(pow.f64 re #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 2 binary64))
(*.f64 re re)
(*.f64 #s(literal 1 binary64) (*.f64 re re))
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 re re)))
(*.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 #s(literal 0 binary64) re))
(*.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) #s(literal -1 binary64)) re)
(*.f64 im (sqrt.f64 #s(literal 1/2 binary64)))
(*.f64 im (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)
(*.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))))
(*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) im))
(*.f64 (*.f64 im (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)))
im
(exp.f64 (*.f64 (log.f64 im) #s(literal 1 binary64)))
(exp.f64 (*.f64 (fma.f64 #s(literal 2 binary64) (log.f64 im) #s(literal 0 binary64)) #s(literal 1/2 binary64)))
(fabs.f64 im)
(fabs.f64 (-.f64 #s(literal 0 binary64) im))
(sqrt.f64 (*.f64 im im))
(pow.f64 im #s(literal 1 binary64))
(pow.f64 (*.f64 im im) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 im) #s(literal 2 binary64))
(*.f64 im #s(literal 1 binary64))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 im (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (sqrt.f64 #s(literal 1/2 binary64)) (*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) #s(literal 1 binary64)))
(*.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 #s(literal 1 binary64) im)
(*.f64 (sqrt.f64 im) (sqrt.f64 im))
(*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (*.f64 im (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 im (sqrt.f64 #s(literal 1/2 binary64)))))
(*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 #s(literal 1/2 binary64)))
(*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 im im) #s(literal 1/4 binary64)) (pow.f64 (*.f64 im im) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (*.f64 im (sqrt.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 binary64) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 #s(literal 2 binary64))))
(*.f64 (*.f64 #s(literal 1 binary64) (*.f64 im (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 #s(literal 1/2 binary64)))
(*.f64 (*.f64 (*.f64 im (sqrt.f64 #s(literal 2 binary64))) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)))

simplify493.0ms (5.2%)

Memory
-56.3MiB live, 789.4MiB allocated
Algorithm
1×egg-herbie
Rules
9 012×accelerator-lowering-fma.f32
9 012×accelerator-lowering-fma.f64
6 768×*-lowering-*.f32
6 768×*-lowering-*.f64
4 794×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

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

eval120.0ms (1.3%)

Memory
36.8MiB live, 310.3MiB allocated
Compiler

Compiled 22 547 to 3 268 computations (85.5% saved)

prune107.0ms (1.1%)

Memory
1.1MiB live, 359.1MiB allocated
Pruning

16 alts after pruning (10 fresh and 6 done)

PrunedKeptTotal
New1 015101 025
Fresh808
Picked235
Done033
Total1 025161 041
Accuracy
100.0%
Counts
1 041 → 16
Alt Table
Click to see full alt table
StatusAccuracyProgram
27.4%
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
▶27.4%
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
42.7%
(*.f64 (*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64))
▶52.4%
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re))) (sqrt.f64 #s(literal 2 binary64)))
▶27.4%
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
13.5%
(*.f64 (sqrt.f64 (*.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)))) #s(literal 1/2 binary64))
▶26.9%
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 binary64))) #s(literal 1/2 binary64))
✓42.9%
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
27.4%
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
✓50.3%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))))
17.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (/.f64 im re) im)))
▶44.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64)))))
✓50.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
✓77.5%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re))))
✓52.7%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re))))
✓5.3%
#s(literal 0 binary64)
Compiler

Compiled 296 to 219 computations (26% saved)

simplify239.0ms (2.5%)

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

Found 18 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
✓cost-diff0
(sqrt.f64 (*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64)))))
✓cost-diff640
(*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64)))
✓cost-diff-64
(*.f64 #s(literal 1/2 binary64) im)
✓cost-diff-64
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
✓cost-diff0
(/.f64 #s(literal 1 binary64) re)
✓cost-diff0
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
✓cost-diff-64
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
✓cost-diff0
(sqrt.f64 re)
✓cost-diff0
(/.f64 im (sqrt.f64 re))
✓cost-diff-64
(*.f64 re #s(literal -4 binary64))
✓cost-diff0
(sqrt.f64 (*.f64 re #s(literal -4 binary64)))
✓cost-diff0
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 binary64))) #s(literal 1/2 binary64))
✓cost-diff0
(-.f64 im re)
✓cost-diff0
(sqrt.f64 (-.f64 im re))
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re)))
✓cost-diff0
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re))) (sqrt.f64 #s(literal 2 binary64)))
Rules
3 866×accelerator-lowering-fma.f32
3 866×accelerator-lowering-fma.f64
3 774×*-lowering-*.f32
3 774×*-lowering-*.f64
2 474×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
028127
157127
295127
3123121
4147121
5271121
6654121
72161121
84924121
08263117
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(* (* 1/2 (sqrt (- im re))) (sqrt 2))
(* 1/2 (sqrt (- im re)))
1/2
(sqrt (- im re))
(- im re)
im
re
(sqrt 2)
2
(* (sqrt (* re -4)) 1/2)
(sqrt (* re -4))
(* re -4)
re
-4
1/2
(* (/ im (sqrt re)) 1/2)
(/ im (sqrt re))
im
(sqrt re)
re
1/2
(* (* 1/2 im) (sqrt (/ 1 re)))
(* 1/2 im)
1/2
im
(sqrt (/ 1 re))
(/ 1 re)
1
re
(* 1/2 (sqrt (* re (+ (* 2 (/ im re)) -2))))
1/2
(sqrt (* re (+ (* 2 (/ im re)) -2)))
(* re (+ (* 2 (/ im re)) -2))
re
(+ (* 2 (/ im re)) -2)
2
(/ im re)
im
-2
Outputs
(* (* 1/2 (sqrt (- im re))) (sqrt 2))
(*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (-.f64 im re)) (sqrt.f64 #s(literal 2 binary64))))
(* 1/2 (sqrt (- im re)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re)))
1/2
#s(literal 1/2 binary64)
(sqrt (- im re))
(sqrt.f64 (-.f64 im re))
(- im re)
(-.f64 im re)
im
re
(sqrt 2)
(sqrt.f64 #s(literal 2 binary64))
2
#s(literal 2 binary64)
(* (sqrt (* re -4)) 1/2)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re #s(literal -4 binary64) #s(literal 0 binary64))))
(sqrt (* re -4))
(sqrt.f64 (fma.f64 re #s(literal -4 binary64) #s(literal 0 binary64)))
(* re -4)
(fma.f64 re #s(literal -4 binary64) #s(literal 0 binary64))
re
-4
#s(literal -4 binary64)
1/2
#s(literal 1/2 binary64)
(* (/ im (sqrt re)) 1/2)
(fma.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) #s(literal 0 binary64))
(/ im (sqrt re))
(/.f64 im (sqrt.f64 re))
im
(sqrt re)
(sqrt.f64 re)
re
1/2
#s(literal 1/2 binary64)
(* (* 1/2 im) (sqrt (/ 1 re)))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 0 binary64))
(* 1/2 im)
(fma.f64 #s(literal 1/2 binary64) im #s(literal 0 binary64))
1/2
#s(literal 1/2 binary64)
im
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(/ 1 re)
(/.f64 #s(literal 1 binary64) re)
1
#s(literal 1 binary64)
re
(* 1/2 (sqrt (* re (+ (* 2 (/ im re)) -2))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im #s(literal 2 binary64) (fma.f64 re #s(literal -2 binary64) #s(literal 0 binary64)))))
1/2
#s(literal 1/2 binary64)
(sqrt (* re (+ (* 2 (/ im re)) -2)))
(sqrt.f64 (fma.f64 im #s(literal 2 binary64) (fma.f64 re #s(literal -2 binary64) #s(literal 0 binary64))))
(* re (+ (* 2 (/ im re)) -2))
(fma.f64 im #s(literal 2 binary64) (fma.f64 re #s(literal -2 binary64) #s(literal 0 binary64)))
re
(+ (* 2 (/ im re)) -2)
(fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))
2
#s(literal 2 binary64)
(/ im re)
(/.f64 im re)
im
-2
#s(literal -2 binary64)

localize85.0ms (0.9%)

Memory
21.3MiB live, 176.6MiB allocated
Localize:

Found 18 expressions of interest:

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

Compiled 125 to 30 computations (76% saved)

Precisions
Click to see histograms. Total time spent on operations: 32.0ms
ival-mult: 13.0ms (40.7% of total)
ival-sqrt: 11.0ms (34.5% of total)
ival-div: 5.0ms (15.7% of total)
ival-sub: 2.0ms (6.3% of total)
ival-add: 1.0ms (3.1% of total)
exact: 1.0ms (3.1% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series31.0ms (0.3%)

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

93 calls:

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

rewrite329.0ms (3.5%)

Memory
-21.7MiB live, 579.5MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
4 122×*-lowering-*.f32
4 122×*-lowering-*.f64
3 674×accelerator-lowering-fma.f32
3 674×accelerator-lowering-fma.f64
2 596×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
028106
1111104
2594104
35825104
08169100
Stop Event
1×iter limit
1×node limit
Counts
20 → 639
Calls
Call 1
Inputs
(* (* 1/2 (sqrt (- im re))) (sqrt 2))
(* 1/2 (sqrt (- im re)))
(sqrt (- im re))
(- im re)
(* (sqrt (* re -4)) 1/2)
(sqrt (* re -4))
(* re -4)
(/ im (sqrt re))
(sqrt re)
(* (/ im (sqrt re)) 1/2)
(sqrt (/ 1 re))
(/ 1 re)
(* (* 1/2 im) (sqrt (/ 1 re)))
(* 1/2 im)
(* re (+ (* 2 (/ im re)) -2))
(* 1/2 (sqrt (* re (+ (* 2 (/ im re)) -2))))
(sqrt (* re (+ (* 2 (/ im re)) -2)))
(+ (* 2 (/ im re)) -2)
(sqrt 2)
(/ im re)
Outputs
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im 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 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im 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 (-.f64 im re) #s(literal 2 binary64))))
(*.f64 (sqrt.f64 (-.f64 im re)) (*.f64 #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 (sqrt.f64 #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re))))
(*.f64 (sqrt.f64 (*.f64 (-.f64 im re) #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 (-.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 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (-.f64 im re)))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im 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 (*.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 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re)))) (sqrt.f64 (+.f64 im re)))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (*.f64 (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re))) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 im re)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re)))
(*.f64 (sqrt.f64 (-.f64 im re)) #s(literal 1/2 binary64))
(*.f64 (pow.f64 (-.f64 im re) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (-.f64 im re) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (-.f64 im re) #s(literal 1/4 binary64))) (pow.f64 (-.f64 im re) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (-.f64 im re))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (-.f64 im re) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (-.f64 im re) (-.f64 im re))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (-.f64 im re)))) #s(literal 1/2 binary64)))
(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 re (+.f64 im re) (*.f64 im im))) (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (+.f64 im re)) (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re)))))
(/.f64 (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (sqrt.f64 (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im))))
(/.f64 (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re))) (sqrt.f64 (+.f64 im re)))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re)))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (+.f64 im re))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (neg.f64 (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im 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))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im im))) (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (+.f64 im re)) (sqrt.f64 (*.f64 (-.f64 im re) (+.f64 im re)))) #s(literal -1 binary64))
(*.f64 (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(*.f64 (sqrt.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re (+.f64 im re) (*.f64 im 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 im (-.f64 #s(literal 0 binary64) re))
(+.f64 (-.f64 #s(literal 0 binary64) re) im)
(+.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(+.f64 (/.f64 (*.f64 im im) (+.f64 im re)) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(exp.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 (-.f64 im re))) #s(literal -1 binary64)))
(-.f64 im re)
(-.f64 #s(literal 0 binary64) (-.f64 re im))
(-.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(-.f64 (/.f64 (*.f64 im im) (+.f64 im re)) (*.f64 re (/.f64 re (+.f64 im re))))
(-.f64 (+.f64 im #s(literal 0 binary64)) re)
(fma.f64 im #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re))
(fma.f64 im (/.f64 (*.f64 im im) (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 im (/.f64 im (+.f64 im re)) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(fma.f64 re #s(literal -1 binary64) im)
(fma.f64 #s(literal 1 binary64) im (-.f64 #s(literal 0 binary64) re))
(fma.f64 #s(literal -1 binary64) re im)
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) re))
(fma.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 1 binary64) im)
(fma.f64 (*.f64 im (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) (+.f64 im re)) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(fma.f64 (*.f64 im im) (/.f64 im (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 (pow.f64 im #s(literal 3/2 binary64)) (/.f64 (pow.f64 im #s(literal 3/2 binary64)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 (*.f64 re (+.f64 im re)) (*.f64 re (+.f64 im re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re (+.f64 im re)) (-.f64 (*.f64 re (+.f64 im re)) (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im)))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))))) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(fma.f64 (/.f64 (*.f64 im im) (*.f64 (-.f64 im re) (+.f64 im re))) (-.f64 im re) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im im) (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re)))) (fma.f64 re (-.f64 re im) (*.f64 im im)) (neg.f64 (*.f64 re (/.f64 re (+.f64 im re)))))
(neg.f64 (/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(neg.f64 (/.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (-.f64 #s(literal 0 binary64) (+.f64 im re))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re))) (+.f64 im re)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 im re)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im)) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re))))
(/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 re (+.f64 im re) (*.f64 im im)))
(/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im)))
(/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 re re (-.f64 (*.f64 im im) (*.f64 im (-.f64 #s(literal 0 binary64) re)))))
(/.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (+.f64 im re))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (neg.f64 (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re))) (-.f64 #s(literal 0 binary64) (+.f64 im re)))
(/.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re)))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (*.f64 (+.f64 im re) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re))))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re))) (*.f64 (+.f64 im re) (fma.f64 im im (*.f64 re re))))
(/.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (-.f64 (*.f64 (*.f64 im im) (+.f64 im re)) (*.f64 (+.f64 im re) (*.f64 re re))) (*.f64 (+.f64 im re) (+.f64 im re)))
(/.f64 (*.f64 (*.f64 (-.f64 im re) (+.f64 im re)) #s(literal 1 binary64)) (+.f64 im re))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))))) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 im im (*.f64 re 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 (fma.f64 im im (*.f64 re re)) (+.f64 im re)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re)))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 im re))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (*.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 im im) (+.f64 im re)) #s(literal 3 binary64)) (pow.f64 (*.f64 re (/.f64 re (+.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 re (/.f64 re (+.f64 im re))) (*.f64 re (/.f64 re (+.f64 im re))) (*.f64 (/.f64 (*.f64 im im) (+.f64 im re)) (*.f64 re (/.f64 re (+.f64 im re)))))))
(/.f64 (-.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (-.f64 #s(literal 0 binary64) re) im))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 im (*.f64 im im)) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im))))) (fma.f64 (*.f64 im im) (/.f64 im (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 (*.f64 re (*.f64 re re)) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 im im) (+.f64 im re)) (/.f64 (*.f64 im im) (+.f64 im re))) (*.f64 (*.f64 re (/.f64 re (+.f64 im re))) (*.f64 re (/.f64 re (+.f64 im re))))) (fma.f64 im (/.f64 im (+.f64 im re)) (*.f64 re (/.f64 re (+.f64 im re)))))
(/.f64 (*.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) #s(literal 1 binary64)) (fma.f64 re (+.f64 im re) (*.f64 im im)))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (+.f64 im re))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (fma.f64 im im (*.f64 re re)))))
(/.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (-.f64 im re) (+.f64 im re))) (/.f64 #s(literal 1 binary64) (+.f64 im re))) (fma.f64 im im (*.f64 re re)))
(pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 im re)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im)) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (-.f64 im re))
(*.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 (-.f64 #s(literal 0 binary64) re) im) (*.f64 im im))))
(*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (*.f64 (-.f64 im re) (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (/.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (/.f64 #s(literal 1 binary64) (+.f64 im re)))
(*.f64 (+.f64 im re) (*.f64 (-.f64 im re) (/.f64 #s(literal 1 binary64) (+.f64 im re))))
(*.f64 (+.f64 im re) (/.f64 (-.f64 im re) (+.f64 im re)))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im)))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (-.f64 im re) (+.f64 im re))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 im re))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (+.f64 im re) (*.f64 im im))) (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 im re)) (*.f64 (-.f64 im re) (+.f64 im re)))
(*.f64 (/.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (*.f64 (-.f64 im re) (+.f64 im re))) (-.f64 im re))
(*.f64 (/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (fma.f64 (*.f64 re (+.f64 im re)) (*.f64 (*.f64 re (+.f64 im re)) (*.f64 re (+.f64 im re))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re (+.f64 im re)) (-.f64 (*.f64 re (+.f64 im re)) (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(*.f64 (/.f64 (*.f64 (-.f64 im re) (fma.f64 re (+.f64 im re) (*.f64 im im))) (*.f64 (fma.f64 re (+.f64 im re) (*.f64 im im)) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))))) (-.f64 (*.f64 im im) (*.f64 re (+.f64 im re))))
(*.f64 (/.f64 (*.f64 (-.f64 im re) (+.f64 im re)) (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re)))) (fma.f64 re (-.f64 re im) (*.f64 im im)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 binary64))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -4 binary64))))
(*.f64 (sqrt.f64 #s(literal -4 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (pow.f64 re #s(literal 1/4 binary64)) (*.f64 (pow.f64 re #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -4 binary64)))))
(*.f64 (pow.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -4 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -4 binary64))) (sqrt.f64 re))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64))) (pow.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re #s(literal -4 binary64)))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (*.f64 re #s(literal -4 binary64)) (*.f64 re #s(literal -4 binary64)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (*.f64 re #s(literal -4 binary64))))) #s(literal 1/2 binary64)))
(sqrt.f64 (*.f64 re #s(literal -4 binary64)))
(pow.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 re #s(literal -4 binary64)) (*.f64 re #s(literal -4 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (*.f64 re #s(literal -4 binary64)))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -4 binary64)))
(*.f64 (sqrt.f64 #s(literal -4 binary64)) (sqrt.f64 re))
(*.f64 (pow.f64 re #s(literal 1/4 binary64)) (*.f64 (pow.f64 re #s(literal 1/4 binary64)) (sqrt.f64 #s(literal -4 binary64))))
(*.f64 (pow.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64)) (pow.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (sqrt.f64 #s(literal -4 binary64)) (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(/.f64 #s(literal -4 binary64) (/.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1 binary64))
(/.f64 (*.f64 #s(literal -4 binary64) (-.f64 #s(literal 0 binary64) re)) #s(literal -1 binary64))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) #s(literal -4 binary64)) #s(literal -1 binary64))
(*.f64 re #s(literal -4 binary64))
(*.f64 #s(literal -4 binary64) re)
(*.f64 (*.f64 re #s(literal -4 binary64)) #s(literal 1 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (sqrt.f64 re) im)) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))) (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (sqrt.f64 re) im)))
(/.f64 im (sqrt.f64 re))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 re) im))
(/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 #s(literal 1 binary64) im))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (sqrt.f64 re) im)))
(/.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (sqrt.f64 re))
(/.f64 (/.f64 im (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(/.f64 (*.f64 im (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(pow.f64 (/.f64 (sqrt.f64 re) im) #s(literal -1 binary64))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) im)
(*.f64 (sqrt.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 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)) (-.f64 #s(literal 0 binary64) im))
(*.f64 (pow.f64 re #s(literal -1/4 binary64)) (*.f64 (pow.f64 re #s(literal -1/4 binary64)) im))
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 im (pow.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (pow.f64 (/.f64 (sqrt.f64 re) im) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (sqrt.f64 re) im) #s(literal -1/2 binary64)))
(*.f64 (*.f64 im (pow.f64 re #s(literal -1/4 binary64))) (pow.f64 re #s(literal -1/4 binary64)))
(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 (pow.f64 re #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(-.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(sqrt.f64 re)
(neg.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (sqrt.f64 re) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(/.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 re)) #s(literal -1 binary64))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) re)) (sqrt.f64 #s(literal -1 binary64)))
(pow.f64 re #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64))
(pow.f64 (*.f64 re re) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 re #s(literal 1/4 binary64)) #s(literal 2 binary64))
(*.f64 (sqrt.f64 re) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (sqrt.f64 re))
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(*.f64 (pow.f64 re #s(literal 1/4 binary64)) (pow.f64 re #s(literal 1/4 binary64)))
(*.f64 (pow.f64 re #s(literal 1/4 binary64)) (/.f64 (pow.f64 re #s(literal 1/4 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) im))) #s(literal -1 binary64)))
(neg.f64 (*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)) #s(literal 1/2 binary64)))
(neg.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re))))
(neg.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(neg.f64 (/.f64 (*.f64 im #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 #s(literal 1/2 binary64) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) im)) #s(literal 1 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 re))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) im))))
(/.f64 #s(literal -1/2 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (sqrt.f64 re) im)))
(/.f64 (*.f64 im #s(literal -1/2 binary64)) (-.f64 #s(literal 0 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 #s(literal 1/2 binary64) im) (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 #s(literal 1/2 binary64) im)) (sqrt.f64 (-.f64 #s(literal 0 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 #s(literal 1/2 binary64) im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) im)) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 1/2 binary64) im))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)) #s(literal 1/2 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)))
(*.f64 (*.f64 im #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (pow.f64 re #s(literal -1/4 binary64)) (*.f64 (pow.f64 re #s(literal -1/4 binary64)) (*.f64 #s(literal 1/2 binary64) im)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 im (pow.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) im) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 im (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) im) (pow.f64 re #s(literal -1/4 binary64))) (pow.f64 re #s(literal -1/4 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))) (-.f64 #s(literal 0 binary64) im))
(exp.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 re) #s(literal 0 binary64)))
(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 (log.f64 (pow.f64 re #s(literal -1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) re))) #s(literal 1/4 binary64)))
(fabs.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(neg.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 re))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (*.f64 #s(literal 1 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (neg.f64 (sqrt.f64 #s(literal -1 binary64))) (neg.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(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 (pow.f64 re #s(literal -1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) re)) #s(literal 1/4 binary64))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal -1 binary64) re)))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(*.f64 (pow.f64 re #s(literal -1/4 binary64)) (pow.f64 re #s(literal -1/4 binary64)))
(*.f64 (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1/2 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (pow.f64 (sqrt.f64 re) #s(literal -1/2 binary64)) (pow.f64 (sqrt.f64 re) #s(literal -1/2 binary64)))
(exp.f64 (-.f64 #s(literal 0 binary64) (log.f64 re)))
(exp.f64 (*.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 re) #s(literal 0 binary64)) #s(literal -2 binary64)))
(exp.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 re)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 re) #s(literal 0 binary64)) #s(literal 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 (*.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) re))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 re))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) re))
(sqrt.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) re)))
(neg.f64 (/.f64 #s(literal -1 binary64) re))
(/.f64 #s(literal 1 binary64) re)
(/.f64 #s(literal 1 binary64) (*.f64 (sqrt.f64 re) (sqrt.f64 re)))
(/.f64 #s(literal 1 binary64) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(/.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64))
(/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 re))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) re))
(/.f64 #s(literal -1 binary64) (*.f64 (sqrt.f64 re) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(/.f64 #s(literal -1 binary64) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 re)) (sqrt.f64 re)))
(/.f64 (*.f64 #s(literal 1 binary64) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (sqrt.f64 re) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(/.f64 (*.f64 #s(literal -1 binary64) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 re)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 1 binary64)) (*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) re)) (sqrt.f64 re)))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) re)) (sqrt.f64 (-.f64 #s(literal 0 binary64) re))))
(/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (*.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (-.f64 #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 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal -1/2 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) re)) #s(literal 1/2 binary64))
(pow.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 re)) #s(literal -1 binary64))
(pow.f64 (*.f64 (-.f64 #s(literal 0 binary64) (sqrt.f64 re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1 binary64))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) re))
(*.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -1 binary64))
(*.f64 (pow.f64 re #s(literal -1/4 binary64)) (*.f64 (pow.f64 re #s(literal -1/4 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (pow.f64 re #s(literal -1/4 binary64))) (pow.f64 re #s(literal -1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) im))) #s(literal -1 binary64)))
(neg.f64 (*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)) #s(literal 1/2 binary64)))
(neg.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re))))
(neg.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(neg.f64 (/.f64 (*.f64 im #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 #s(literal 1/2 binary64) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) im)) #s(literal 1 binary64)))
(/.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 re))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) im))))
(/.f64 #s(literal -1/2 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (sqrt.f64 re) im)))
(/.f64 (*.f64 im #s(literal -1/2 binary64)) (-.f64 #s(literal 0 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 #s(literal 1/2 binary64) im) (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (sqrt.f64 re)))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (-.f64 #s(literal 0 binary64) re)))
(/.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 #s(literal 1/2 binary64) im)) (sqrt.f64 (-.f64 #s(literal 0 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 #s(literal 1/2 binary64) im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) im)) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 re)))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re))))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 #s(literal 1/2 binary64) im))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 #s(literal -1 binary64) (sqrt.f64 re)) #s(literal 1/2 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))))
(*.f64 #s(literal -1/2 binary64) (/.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 re)))
(*.f64 (*.f64 im #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (sqrt.f64 re)))
(*.f64 (pow.f64 re #s(literal -1/4 binary64)) (*.f64 (pow.f64 re #s(literal -1/4 binary64)) (*.f64 #s(literal 1/2 binary64) im)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 im (pow.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 (*.f64 #s(literal 1/2 binary64) im) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 im (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) (pow.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 1/4 binary64))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) im) (pow.f64 re #s(literal -1/4 binary64))) (pow.f64 re #s(literal -1/4 binary64)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) (sqrt.f64 re))) (-.f64 #s(literal 0 binary64) im))
(*.f64 #s(literal 1/2 binary64) im)
(*.f64 im #s(literal 1/2 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) im))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64))
(+.f64 (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re) (*.f64 re #s(literal -2 binary64)))
(+.f64 (*.f64 re #s(literal -2 binary64)) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 re re)) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))) (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 re re)) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))))
(fma.f64 im (*.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 re #s(literal 2 binary64))) (*.f64 re #s(literal -2 binary64)))
(fma.f64 im (*.f64 (/.f64 #s(literal 2 binary64) re) re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 re (/.f64 (*.f64 im #s(literal 2 binary64)) re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 re #s(literal -2 binary64) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re))
(fma.f64 #s(literal 2 binary64) (/.f64 (*.f64 im re) re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im (*.f64 re #s(literal 2 binary64))) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (/.f64 im re) (*.f64 re #s(literal 2 binary64)) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (/.f64 (*.f64 im #s(literal 2 binary64)) re) re (*.f64 re #s(literal -2 binary64)))
(fma.f64 #s(literal -2 binary64) re (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 #s(literal -1 binary64) re) (*.f64 re #s(literal 2 binary64))) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (*.f64 im re) (/.f64 #s(literal 2 binary64) re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re) #s(literal 1 binary64) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (*.f64 re #s(literal -2 binary64)) #s(literal 1 binary64) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re))
(fma.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) re) re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (*.f64 im #s(literal 2 binary64)) (/.f64 re re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (/.f64 (*.f64 im re) re) #s(literal 2 binary64) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (*.f64 re #s(literal 2 binary64)) (/.f64 im re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (/.f64 re re) (/.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1 binary64)) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (*.f64 (*.f64 re #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) re)) im (*.f64 re #s(literal -2 binary64)))
(fma.f64 (*.f64 (*.f64 re #s(literal 2 binary64)) (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal -1 binary64) re) (*.f64 re #s(literal -2 binary64)))
(fma.f64 (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) re)) #s(literal -1 binary64) (*.f64 re #s(literal -2 binary64)))
(/.f64 re (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))))
(/.f64 re (*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))))
(/.f64 re (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (/.f64 #s(literal 1 binary64) re)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 re re) (*.f64 (*.f64 re #s(literal -2 binary64)) (-.f64 (*.f64 re #s(literal -2 binary64)) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re)) (*.f64 #s(literal -8 binary64) (*.f64 re (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))) (*.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)) (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))))
(/.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)) (/.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) re) (*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))))
(/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re)) (*.f64 #s(literal -8 binary64) (*.f64 re (*.f64 re re)))) (fma.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 re re) (*.f64 (*.f64 re #s(literal -2 binary64)) (-.f64 (*.f64 re #s(literal -2 binary64)) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re)))))
(/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re)) (*.f64 #s(literal -8 binary64) (*.f64 re (*.f64 re re)))) (fma.f64 #s(literal 4 binary64) (*.f64 re re) (-.f64 (*.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 re re)) (*.f64 (/.f64 (*.f64 im re) re) (*.f64 #s(literal 2 binary64) (*.f64 re #s(literal -2 binary64)))))))
(/.f64 (*.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(/.f64 (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))
(/.f64 (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (*.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (*.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)) #s(literal 1 binary64)))
(/.f64 (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))
(/.f64 (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (*.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(/.f64 (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) #s(literal 1 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal -1 binary64)))
(/.f64 (*.f64 re (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 re (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))))
(/.f64 (*.f64 re (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))
(/.f64 (*.f64 re (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) (*.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))
(/.f64 (*.f64 re (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))) (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re)))
(/.f64 (*.f64 re (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))) (*.f64 #s(literal 1 binary64) (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re))))
(/.f64 (*.f64 #s(literal 1 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) re) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) re) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) re) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))
(/.f64 (*.f64 #s(literal 1 binary64) (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))) (*.f64 (/.f64 #s(literal 1 binary64) re) (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) (*.f64 #s(literal -1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))) (*.f64 #s(literal -1 binary64) (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re))))
(/.f64 (*.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) #s(literal 1 binary64)) (*.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)) (/.f64 #s(literal 1 binary64) re)))
(/.f64 (*.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) (-.f64 #s(literal 0 binary64) re)) (*.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)) #s(literal -1 binary64)))
(/.f64 (*.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) #s(literal 1 binary64)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) re)))
(/.f64 (*.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (-.f64 #s(literal 0 binary64) re)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) #s(literal -1 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) re) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) re) (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))) #s(literal 1 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) #s(literal 1 binary64)) (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))) (/.f64 #s(literal 1 binary64) re)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (-.f64 #s(literal 0 binary64) re)) (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))) #s(literal -1 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) re) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) re) (*.f64 (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)) #s(literal 1 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)) (/.f64 #s(literal 1 binary64) re)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (-.f64 #s(literal 0 binary64) re)) (*.f64 (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)) #s(literal -1 binary64)))
(/.f64 (*.f64 (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) re) (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re)))
(/.f64 (*.f64 (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) re) (*.f64 (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re)) #s(literal 1 binary64)))
(/.f64 (*.f64 (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) #s(literal 1 binary64)) (*.f64 (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re)) (/.f64 #s(literal 1 binary64) re)))
(/.f64 (*.f64 (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) (-.f64 #s(literal 0 binary64) re)) (*.f64 (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re)) #s(literal -1 binary64)))
(/.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re)) (*.f64 #s(literal -8 binary64) (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 re re) (*.f64 (*.f64 re #s(literal -2 binary64)) (-.f64 (*.f64 re #s(literal -2 binary64)) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re))))))
(/.f64 (neg.f64 (*.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))) (neg.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (neg.f64 (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 4 binary64) (*.f64 re re)) (*.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 re re))) (-.f64 (*.f64 re #s(literal -2 binary64)) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re)))
(/.f64 (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)) (-.f64 #s(literal 0 binary64) re)) #s(literal -1 binary64))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal -1 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))) #s(literal -1 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 re re) (*.f64 (*.f64 re #s(literal -2 binary64)) (-.f64 (*.f64 re #s(literal -2 binary64)) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re)))) (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re)) (*.f64 #s(literal -8 binary64) (*.f64 re (*.f64 re re))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))) (*.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)) (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) #s(literal -1 binary64))
(*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))
(*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)) re)
(*.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1 binary64))
(*.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))) re))
(*.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) (/.f64 re (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(*.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (*.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))) re))
(*.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (/.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re)) (*.f64 #s(literal -8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 re re) (*.f64 (*.f64 re #s(literal -2 binary64)) (-.f64 (*.f64 re #s(literal -2 binary64)) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re))))))
(*.f64 (*.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))))
(*.f64 (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(*.f64 (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))
(*.f64 (/.f64 (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (fma.f64 (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64)) (*.f64 (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64)) (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (fma.f64 (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64)) (-.f64 (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64)) (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re))) (/.f64 (*.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 #s(literal 4 binary64) (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (*.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)) (+.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (*.f64 #s(literal -4 binary64) (/.f64 im re))))) (+.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (*.f64 #s(literal -4 binary64) (/.f64 im re))))
(*.f64 (/.f64 (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))
(*.f64 (/.f64 (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal 8 binary64))) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -4 binary64) (/.f64 im re) #s(literal 4 binary64))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) (sqrt.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))))
(*.f64 (sqrt.f64 re) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))))
(*.f64 (sqrt.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (pow.f64 re #s(literal 1/4 binary64)) (*.f64 (pow.f64 re #s(literal 1/4 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))))))
(*.f64 (pow.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1/4 binary64)) (*.f64 (pow.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1/4 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))) (sqrt.f64 re))
(*.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1/4 binary64))) (pow.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))))))
(exp.f64 (*.f64 (log.f64 (pow.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))))) #s(literal 1/2 binary64)))
(sqrt.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))))
(/.f64 (sqrt.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re re)) (*.f64 #s(literal -8 binary64) (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (*.f64 re re) (*.f64 (*.f64 re #s(literal -2 binary64)) (-.f64 (*.f64 re #s(literal -2 binary64)) (/.f64 (*.f64 im (*.f64 re #s(literal 2 binary64))) re))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))) (sqrt.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))))
(/.f64 (sqrt.f64 (*.f64 re (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) (sqrt.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (sqrt.f64 (*.f64 re (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(/.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) (sqrt.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 (sqrt.f64 re) (sqrt.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (sqrt.f64 re)) (sqrt.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 (sqrt.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (sqrt.f64 re)) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(pow.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))))) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 re) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))))
(*.f64 (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (sqrt.f64 re))
(*.f64 (pow.f64 re #s(literal 1/4 binary64)) (*.f64 (pow.f64 re #s(literal 1/4 binary64)) (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))))
(*.f64 (pow.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1/4 binary64)) (pow.f64 (*.f64 re (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1/4 binary64)))
(*.f64 (*.f64 (sqrt.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) (pow.f64 re #s(literal 1/4 binary64))) (pow.f64 re #s(literal 1/4 binary64)))
(+.f64 (/.f64 (*.f64 im #s(literal 2 binary64)) re) #s(literal -2 binary64))
(+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal 2 binary64)) re))
(+.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re re))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re re))) (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))
(-.f64 (/.f64 #s(literal 4 binary64) (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re))) (/.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re))))
(fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
(fma.f64 #s(literal 2 binary64) (/.f64 (/.f64 (*.f64 (*.f64 im #s(literal 2 binary64)) im) (*.f64 re re)) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 im #s(literal 2 binary64)) re) #s(literal -2 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) re) (*.f64 im #s(literal 2 binary64)) #s(literal -2 binary64))
(fma.f64 (/.f64 im re) #s(literal 2 binary64) #s(literal -2 binary64))
(fma.f64 (/.f64 im re) (/.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(fma.f64 (/.f64 (*.f64 im #s(literal 2 binary64)) re) #s(literal 1 binary64) #s(literal -2 binary64))
(fma.f64 (/.f64 (*.f64 im #s(literal 2 binary64)) re) (/.f64 (/.f64 (*.f64 im #s(literal 2 binary64)) re) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(fma.f64 #s(literal -2 binary64) (/.f64 im (-.f64 #s(literal 0 binary64) re)) #s(literal -2 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (*.f64 (/.f64 #s(literal -1 binary64) re) #s(literal 2 binary64)) #s(literal -2 binary64))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) re)) #s(literal -2 binary64))
(fma.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(fma.f64 #s(literal 4 binary64) (/.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(fma.f64 (*.f64 im #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal -2 binary64))
(fma.f64 (*.f64 im #s(literal -2 binary64)) (/.f64 #s(literal -1 binary64) re) #s(literal -2 binary64))
(fma.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) (/.f64 (/.f64 im re) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(fma.f64 (/.f64 (*.f64 im #s(literal -2 binary64)) re) #s(literal -1 binary64) #s(literal -2 binary64))
(fma.f64 (/.f64 (*.f64 (*.f64 im #s(literal 2 binary64)) im) (*.f64 re re)) (/.f64 #s(literal 2 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(fma.f64 (/.f64 #s(literal 2 binary64) re) im #s(literal -2 binary64))
(fma.f64 (/.f64 #s(literal 2 binary64) re) (/.f64 im #s(literal 1 binary64)) #s(literal -2 binary64))
(fma.f64 (*.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal -2 binary64))
(fma.f64 (*.f64 (*.f64 im #s(literal 2 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) re) #s(literal -2 binary64))
(fma.f64 (/.f64 (*.f64 im #s(literal 2 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) re) #s(literal -2 binary64))
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64)) (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))
(fma.f64 (*.f64 (*.f64 im #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal -2 binary64))
(fma.f64 (/.f64 #s(literal 2 binary64) (-.f64 #s(literal 0 binary64) re)) (-.f64 #s(literal 0 binary64) im) #s(literal -2 binary64))
(fma.f64 (/.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(fma.f64 (/.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal 8 binary64))) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -4 binary64) (/.f64 im re) #s(literal 4 binary64))) (neg.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(neg.f64 (/.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))))
(neg.f64 (/.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re)) (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))))
(/.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))
(/.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))
(/.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal -512 binary64)) (*.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)) (-.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal 64 binary64)) (*.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -64 binary64)))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal -64 binary64)) (*.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal 8 binary64))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal -64 binary64)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 #s(literal 4 binary64) (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 16 binary64) #s(literal 16 binary64)))))
(/.f64 (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re)))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 #s(literal 4 binary64) (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -16 binary64)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 4 binary64))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re)) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) #s(literal 4 binary64))) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal -512 binary64)) #s(literal 1 binary64)) (*.f64 (-.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal 64 binary64)) (*.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -64 binary64))) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) #s(literal 1 binary64)) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))
(/.f64 (*.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) #s(literal 1 binary64)) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)))
(/.f64 (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal -64 binary64)) #s(literal 1 binary64)) (*.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal 8 binary64)) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(/.f64 (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal -64 binary64)) #s(literal 1 binary64)) (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 #s(literal 4 binary64) (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 16 binary64) #s(literal 16 binary64))) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(/.f64 (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 #s(literal 4 binary64) (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -16 binary64)) #s(literal 1 binary64)) (*.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 4 binary64)) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))) (neg.f64 (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))
(/.f64 (neg.f64 (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))) (neg.f64 (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re re))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re re))) (fma.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))) (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))) (*.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re re))) (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re re))) (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re re)))) (*.f64 (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))) (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))) (+.f64 (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal 2 binary64)) (*.f64 re re))) (/.f64 #s(literal -4 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))))
(/.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 re (*.f64 re re))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal -512 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))) (-.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal 64 binary64)) (*.f64 (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -64 binary64))))
(/.f64 (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal -64 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal 8 binary64)))
(/.f64 (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal -64 binary64)) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))) (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 #s(literal 4 binary64) (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 16 binary64) #s(literal 16 binary64))))
(/.f64 (*.f64 (+.f64 (/.f64 (*.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 #s(literal 4 binary64) (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -16 binary64)) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64)))) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal 4 binary64)))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re)) (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re))))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))
(*.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))))
(*.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)))))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64))) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal -2 binary64))) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)))
(*.f64 (+.f64 #s(literal 4 binary64) (*.f64 #s(literal -4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal -2 binary64) (/.f64 (*.f64 im #s(literal -2 binary64)) re))))
(*.f64 (/.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64))) (fma.f64 im (/.f64 #s(literal 2 binary64) re) #s(literal -2 binary64)))
(*.f64 (/.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) (fma.f64 (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64)) (*.f64 (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64)) (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64))) (/.f64 (*.f64 (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64)) (*.f64 (*.f64 im (*.f64 im im)) #s(literal 8 binary64))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (fma.f64 (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64)) (-.f64 (fma.f64 (/.f64 im re) #s(literal 4 binary64) #s(literal 4 binary64)) (/.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 re re))) (/.f64 (*.f64 (*.f64 #s(literal 4 binary64) (*.f64 im im)) (*.f64 #s(literal 4 binary64) (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal -8 binary64)) (*.f64 (fma.f64 (/.f64 im re) (-.f64 (*.f64 (/.f64 im re) #s(literal 4 binary64)) #s(literal -4 binary64)) #s(literal 4 binary64)) (+.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (*.f64 #s(literal -4 binary64) (/.f64 im re))))) (+.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (*.f64 #s(literal -4 binary64) (/.f64 im re))))
(*.f64 (/.f64 (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) #s(literal -4 binary64)) (fma.f64 #s(literal 8 binary64) (/.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))) #s(literal 8 binary64))) (fma.f64 #s(literal 4 binary64) (/.f64 (*.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -4 binary64) (/.f64 im re) #s(literal 4 binary64))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 #s(literal 4 binary64)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 #s(literal 2 binary64) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.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 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 (/.f64 #s(literal -1 binary64) re) im))
(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 #s(literal 1 binary64) (/.f64 re im))
(/.f64 (/.f64 #s(literal 1 binary64) re) (/.f64 #s(literal 1 binary64) im))
(/.f64 (/.f64 im re) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 re im)))
(/.f64 (-.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 #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)) re)
(pow.f64 (/.f64 re im) #s(literal -1 binary64))
(*.f64 im (/.f64 #s(literal 1 binary64) re))
(*.f64 (/.f64 im (sqrt.f64 re)) (sqrt.f64 (/.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 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 re)))
(*.f64 (/.f64 im re) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 im (-.f64 #s(literal 0 binary64) re)))
(*.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) re) im))
(*.f64 (-.f64 #s(literal 0 binary64) im) (/.f64 #s(literal -1 binary64) re))
(*.f64 (/.f64 #s(literal -1 binary64) re) (-.f64 #s(literal 0 binary64) im))
(*.f64 (/.f64 im (-.f64 #s(literal 0 binary64) re)) #s(literal -1 binary64))
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) 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 (pow.f64 (/.f64 re im) #s(literal -1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal -1/2 binary64)))

simplify482.0ms (5.1%)

Memory
9.8MiB live, 802.5MiB allocated
Algorithm
1×egg-herbie
Rules
12 024×accelerator-lowering-fma.f32
12 024×accelerator-lowering-fma.f64
7 552×*-lowering-*.f32
7 552×*-lowering-*.f64
4 194×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
06455348
122105003
268864919
081994725
Stop Event
1×iter limit
1×node limit
Counts
372 → 372
Calls
Call 1
Inputs
(* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2))))
(+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2)))))
(+ (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2)))) (* im (+ (* -1/16 (* (/ (* im (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (/ (sqrt 2) (sqrt -1)))))))
(+ (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2)))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (/ (sqrt 2) (sqrt -1)))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (/ (sqrt 2) (pow (sqrt -1) 3)))) (* 1/32 (* (/ (* im (sqrt 2)) (pow (sqrt -1) 5)) (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/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -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/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 (* (pow (sqrt -1) 2) (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) (* (pow (sqrt -1) 2) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (pow (sqrt -1) 2) (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) (* (pow (sqrt -1) 2) (sqrt 2))))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (* (pow (sqrt -1) 2) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (pow (sqrt -1) 2) (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/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* -1/16 (* (sqrt (/ 1 (pow im 3))) (* re (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 -1) (sqrt 2))))
(* re (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))
(* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))
(* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))))
(* -1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2))))
(* -1 (* re (+ (* 1/4 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))
(* -1 (* re (+ (* -1/16 (* (* (pow im 2) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))))
(* -1 (* re (+ (* -1/16 (* (* (pow im 2) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))))
(* 1/2 (* (sqrt re) (sqrt -1)))
(+ (* 1/4 (* (/ im (sqrt -1)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (sqrt -1))))
(+ (* 1/2 (* (sqrt re) (sqrt -1))) (* im (+ (* -1/16 (* (/ im (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (/ 1 (sqrt -1)))))))
(+ (* 1/2 (* (sqrt re) (sqrt -1))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (/ 1 (sqrt -1)))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (/ 1 (pow (sqrt -1) 3)))) (* 1/32 (* (/ im (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 5))))))))))
(* 1/2 (sqrt im))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (sqrt (/ 1 im)))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* 1/2 (sqrt (/ 1 im))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (+ (* -1/32 (* (sqrt (/ 1 (pow im 7))) (pow re 3))) (* 1/2 (sqrt (/ 1 im)))))))
(* -1/2 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* 1/2 (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* 1/2 (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* 1/2 (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))))
(* 1/2 (sqrt im))
(+ (* -1/4 (* (sqrt (/ 1 im)) re)) (* 1/2 (sqrt im)))
(+ (* 1/2 (sqrt im)) (* re (+ (* -1/4 (sqrt (/ 1 im))) (* -1/16 (* (sqrt (/ 1 (pow im 3))) re)))))
(+ (* 1/2 (sqrt im)) (* re (+ (* -1/4 (sqrt (/ 1 im))) (* re (+ (* -1/16 (sqrt (/ 1 (pow im 3)))) (* -1/32 (* (sqrt (/ 1 (pow im 5))) re)))))))
(* 1/2 (* (sqrt re) (sqrt -1)))
(* re (+ (* 1/4 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1)))))
(* re (+ (* -1/16 (* (/ (pow im 2) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1))))))
(* re (+ (* -1/16 (* (/ (pow im 2) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (pow im 3) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1)))))))
(* -1/2 (* (sqrt re) (sqrt -1)))
(* -1 (* re (+ (* 1/4 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1))))))
(* -1 (* re (+ (* -1/16 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1)))))))
(* -1 (* re (+ (* -1/16 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (sqrt -1)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1))))))))
(* (sqrt re) (sqrt -1))
(+ (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re)))) (* (sqrt re) (sqrt -1)))
(+ (* im (+ (* -1/8 (* (/ im (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (/ 1 (sqrt -1)))))) (* (sqrt re) (sqrt -1)))
(+ (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (/ 1 (sqrt -1)))) (* im (+ (* -1/8 (* (sqrt (/ 1 (pow re 3))) (/ 1 (pow (sqrt -1) 3)))) (* 1/16 (* (/ im (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 5))))))))) (* (sqrt re) (sqrt -1)))
(sqrt im)
(* im (+ (sqrt (/ 1 im)) (* -1/2 (* (sqrt (/ 1 (pow im 3))) re))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* -1/16 (* (sqrt (/ 1 (pow im 7))) (pow re 3)))))))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* (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 (pow (sqrt -1) 2)))) (* (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) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))
(sqrt im)
(+ (sqrt im) (* -1/2 (* (sqrt (/ 1 im)) re)))
(+ (sqrt im) (* re (+ (* -1/2 (sqrt (/ 1 im))) (* -1/8 (* (sqrt (/ 1 (pow im 3))) re)))))
(+ (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) (sqrt -1))
(* re (+ (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1))))
(* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1)))))
(* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (pow im 3) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1))))))
(* -1 (* (sqrt re) (sqrt -1)))
(* -1 (* re (+ (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1)))))
(* -1 (* re (+ (* -1/8 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1))))))
(* -1 (* re (+ (* -1/8 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (* (pow im 3) (sqrt -1)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1)))))))
(* -1 re)
(- im re)
(- im re)
(- im re)
im
(* im (+ 1 (* -1 (/ re im))))
(* im (+ 1 (* -1 (/ re im))))
(* im (+ 1 (* -1 (/ re im))))
im
(* -1 (* im (- (/ re im) 1)))
(* -1 (* im (- (/ re im) 1)))
(* -1 (* im (- (/ re im) 1)))
im
(+ im (* -1 re))
(+ im (* -1 re))
(+ im (* -1 re))
(* -1 re)
(* re (- (/ im re) 1))
(* re (- (/ im re) 1))
(* re (- (/ im re) 1))
(* -1 re)
(* -1 (* re (+ 1 (* -1 (/ im re)))))
(* -1 (* re (+ 1 (* -1 (/ im re)))))
(* -1 (* re (+ 1 (* -1 (/ im re)))))
(* 1/2 (* (sqrt re) (sqrt -4)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(* -1 (* (sqrt re) (sqrt -1)))
(* -1 (* (sqrt re) (sqrt -1)))
(* -1 (* (sqrt re) (sqrt -1)))
(* -1 (* (sqrt re) (sqrt -1)))
(* (sqrt re) (sqrt -4))
(* (sqrt re) (sqrt -4))
(* (sqrt re) (sqrt -4))
(* (sqrt re) (sqrt -4))
(* (sqrt re) (sqrt -4))
(* (sqrt re) (sqrt -4))
(* (sqrt re) (sqrt -4))
(* (sqrt re) (sqrt -4))
(* -2 (* (sqrt re) (sqrt -1)))
(* -2 (* (sqrt re) (sqrt -1)))
(* -2 (* (sqrt re) (sqrt -1)))
(* -2 (* (sqrt re) (sqrt -1)))
(* -4 re)
(* -4 re)
(* -4 re)
(* -4 re)
(* -4 re)
(* -4 re)
(* -4 re)
(* -4 re)
(* -4 re)
(* -4 re)
(* -4 re)
(* -4 re)
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(* im (sqrt (/ 1 re)))
(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)))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(sqrt (/ 1 re))
(sqrt (/ 1 re))
(sqrt (/ 1 re))
(sqrt (/ 1 re))
(sqrt (/ 1 re))
(sqrt (/ 1 re))
(sqrt (/ 1 re))
(sqrt (/ 1 re))
(* (sqrt (/ 1 re)) (pow (sqrt -1) 2))
(* (sqrt (/ 1 re)) (pow (sqrt -1) 2))
(* (sqrt (/ 1 re)) (pow (sqrt -1) 2))
(* (sqrt (/ 1 re)) (pow (sqrt -1) 2))
(/ 1 re)
(/ 1 re)
(/ 1 re)
(/ 1 re)
(/ 1 re)
(/ 1 re)
(/ 1 re)
(/ 1 re)
(/ 1 re)
(/ 1 re)
(/ 1 re)
(/ 1 re)
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* im (sqrt (/ 1 re))))
(* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))
(* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 1/2 im)
(* 2 im)
(+ (* -2 re) (* 2 im))
(+ (* -2 re) (* 2 im))
(+ (* -2 re) (* 2 im))
(* -2 re)
(* re (- (* 2 (/ im re)) 2))
(* re (- (* 2 (/ im re)) 2))
(* re (- (* 2 (/ im re)) 2))
(* -2 re)
(* -1 (* re (+ 2 (* -2 (/ im re)))))
(* -1 (* re (+ 2 (* -2 (/ im re)))))
(* -1 (* re (+ 2 (* -2 (/ im re)))))
(* -2 re)
(+ (* -2 re) (* 2 im))
(+ (* -2 re) (* 2 im))
(+ (* -2 re) (* 2 im))
(* 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)))
(* 1/2 (* (sqrt im) (sqrt 2)))
(+ (* -1/2 (* (sqrt (/ 1 im)) (/ re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* -1/4 (* (sqrt (/ 1 (pow im 3))) (/ re (pow (sqrt 2) 3)))))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* re (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (/ 1 (pow (sqrt 2) 3)))) (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ re (pow (sqrt 2) 5)))))))))
(* 1/2 (* (sqrt re) (sqrt -2)))
(* re (+ (* 1/2 (* (sqrt (/ 1 re)) (sqrt -2))) (* 1/2 (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3)))))))
(* re (+ (* -1/4 (* (/ (pow im 2) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (sqrt (/ 1 re)) (sqrt -2))) (* 1/2 (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3))))))))
(* re (+ (* -1/4 (* (/ (pow im 2) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (/ (pow im 3) (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (sqrt (/ 1 re)) (sqrt -2))) (* 1/2 (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3)))))))))
(* -1/2 (* (sqrt re) (* (sqrt -2) (pow (sqrt -1) 2))))
(* -1 (* re (+ (* -1/2 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2)))))))
(* -1 (* re (+ (* -1/2 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (+ (* -1/4 (* (/ (* (pow im 2) (pow (sqrt -1) 2)) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2))))))))
(* -1 (* re (+ (* -1/2 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (+ (* -1/4 (* (/ (* (pow im 2) (pow (sqrt -1) 2)) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/4 (* (/ (* (pow im 3) (pow (sqrt -1) 2)) (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 7))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2)))))))))
(* 1/2 (* (sqrt re) (sqrt -2)))
(+ (* 1/2 (* (sqrt re) (sqrt -2))) (* 1/2 (* (/ im (sqrt -2)) (sqrt (/ 1 re)))))
(+ (* 1/2 (* (sqrt re) (sqrt -2))) (* im (+ (* -1/4 (* (/ im (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (/ 1 (sqrt -2)))))))
(+ (* 1/2 (* (sqrt re) (sqrt -2))) (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (/ 1 (sqrt -2)))) (* im (+ (* -1/4 (* (sqrt (/ 1 (pow re 3))) (/ 1 (pow (sqrt -2) 3)))) (* 1/4 (* (/ im (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 5))))))))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2))))))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt 2) 5)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2)))))))
(* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (pow (sqrt -1) 2)) (pow (sqrt 2) 3)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2))))))))
(* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (pow (sqrt -1) 2)) (pow (sqrt 2) 3)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (pow (sqrt -1) 2)) (pow (sqrt 2) 5)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2)))))))))
(* (sqrt im) (sqrt 2))
(+ (* -1 (* (sqrt (/ 1 im)) (/ re (sqrt 2)))) (* (sqrt im) (sqrt 2)))
(+ (* re (+ (* -1 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* -1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (pow (sqrt 2) 3)))))) (* (sqrt im) (sqrt 2)))
(+ (* re (+ (* -1 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* re (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (/ 1 (pow (sqrt 2) 3)))) (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ re (pow (sqrt 2) 5)))))))) (* (sqrt im) (sqrt 2)))
(* (sqrt re) (sqrt -2))
(* re (+ (* (sqrt (/ 1 re)) (sqrt -2)) (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3))))))
(* re (+ (* -1/2 (* (/ (pow im 2) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* (sqrt (/ 1 re)) (sqrt -2)) (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3)))))))
(* re (+ (* -1/2 (* (/ (pow im 2) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (/ (pow im 3) (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* (sqrt (/ 1 re)) (sqrt -2)) (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3))))))))
(* -1 (* (sqrt re) (* (sqrt -2) (pow (sqrt -1) 2))))
(* -1 (* re (+ (* -1 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2))))))
(* -1 (* re (+ (* -1 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (/ (* (pow im 2) (pow (sqrt -1) 2)) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2)))))))
(* -1 (* re (+ (* -1 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (/ (* (pow im 2) (pow (sqrt -1) 2)) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/2 (* (/ (* (pow im 3) (pow (sqrt -1) 2)) (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 7))))) (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2))))))))
(* (sqrt re) (sqrt -2))
(+ (* (sqrt re) (sqrt -2)) (* (/ im (sqrt -2)) (sqrt (/ 1 re))))
(+ (* im (+ (* -1/2 (* (/ im (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (/ 1 (sqrt -2))))) (* (sqrt re) (sqrt -2)))
(+ (* im (+ (* im (+ (* -1/2 (* (sqrt (/ 1 (pow re 3))) (/ 1 (pow (sqrt -2) 3)))) (* 1/2 (* (/ im (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 5))))))) (* (sqrt (/ 1 re)) (/ 1 (sqrt -2))))) (* (sqrt re) (sqrt -2)))
(* (sqrt im) (sqrt 2))
(* im (+ (* -1 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (* (sqrt (/ 1 im)) (sqrt 2))))
(* im (+ (* -1 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (* (sqrt (/ 1 im)) (sqrt 2)))))
(* im (+ (* -1 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt 2) 5)))) (* (sqrt (/ 1 im)) (sqrt 2))))))
(* -1 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(* -1 (* im (+ (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2))))))
(* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (pow (sqrt -1) 2)) (pow (sqrt 2) 3)))) (+ (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2)))))))
(* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (pow (sqrt -1) 2)) (pow (sqrt 2) 3)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (pow (sqrt -1) 2)) (pow (sqrt 2) 5)))) (+ (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2))))))))
-2
(- (* 2 (/ im re)) 2)
(- (* 2 (/ im re)) 2)
(- (* 2 (/ im re)) 2)
(* 2 (/ im re))
(* im (- (* 2 (/ 1 re)) (* 2 (/ 1 im))))
(* im (- (* 2 (/ 1 re)) (* 2 (/ 1 im))))
(* im (- (* 2 (/ 1 re)) (* 2 (/ 1 im))))
(* 2 (/ im re))
(* -1 (* im (- (* 2 (/ 1 im)) (* 2 (/ 1 re)))))
(* -1 (* im (- (* 2 (/ 1 im)) (* 2 (/ 1 re)))))
(* -1 (* im (- (* 2 (/ 1 im)) (* 2 (/ 1 re)))))
(* 2 (/ im re))
(/ (+ (* -2 re) (* 2 im)) re)
(/ (+ (* -2 re) (* 2 im)) re)
(/ (+ (* -2 re) (* 2 im)) re)
-2
(- (* 2 (/ im re)) 2)
(- (* 2 (/ im re)) 2)
(- (* 2 (/ im re)) 2)
-2
(- (* 2 (/ im re)) 2)
(- (* 2 (/ im re)) 2)
(- (* 2 (/ im re)) 2)
(/ 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)
Outputs
(* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64)))
(+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2)))))
(fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64)))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64))))
(+ (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2)))) (* im (+ (* -1/16 (* (/ (* im (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (/ (sqrt 2) (sqrt -1)))))))
(fma.f64 im (fma.f64 (/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/16 binary64) (*.f64 (*.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64))))
(+ (* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2)))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (/ (sqrt 2) (sqrt -1)))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (/ (sqrt 2) (pow (sqrt -1) 3)))) (* 1/32 (* (/ (* im (sqrt 2)) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 5))))))))))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal 1/32 binary64) (*.f64 (/.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 5 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))) (*.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 #s(literal -1 binary64))))) (*.f64 (*.f64 #s(literal 1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal -1 binary64))))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 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 #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)))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (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 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (sqrt.f64 #s(literal 2 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))))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))) (+ (* -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/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/32 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (sqrt.f64 #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (pow (sqrt -1) 2) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))
(*.f64 (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64)) (sqrt.f64 #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) 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) (* (pow (sqrt -1) 2) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (pow (sqrt -1) 2) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))))))))
(*.f64 (fma.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))) (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64)) (sqrt.f64 #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) 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) (* (pow (sqrt -1) 2) (sqrt 2))))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (* (pow (sqrt -1) 2) (sqrt 2))))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (* (pow (sqrt -1) 2) (sqrt 2))))) (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))))))))
(*.f64 (fma.f64 #s(literal 1/32 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (*.f64 (*.f64 re (*.f64 re re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))))) (fma.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))) (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64)) (sqrt.f64 #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) re))) (sqrt.f64 #s(literal 2 binary64)))))) (-.f64 #s(literal 0 binary64) im))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(+ (* -1/4 (* (sqrt (/ 1 im)) (* re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 #s(literal -1/4 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (sqrt.f64 #s(literal 2 binary64))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/4 (* (sqrt (/ 1 im)) (sqrt 2))) (* -1/16 (* (sqrt (/ 1 (pow im 3))) (* re (sqrt 2)))))))
(fma.f64 re (fma.f64 re (*.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 (*.f64 #s(literal -1/4 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 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 re (fma.f64 re (fma.f64 (*.f64 #s(literal -1/32 binary64) (*.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/16 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))))) (*.f64 (*.f64 #s(literal -1/4 binary64) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64))))
(* 1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2))))
(*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 #s(literal 2 binary64)))
(* re (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))
(*.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (sqrt.f64 #s(literal -1 binary64))))))
(* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))
(*.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (fma.f64 (*.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im) (sqrt.f64 #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 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (sqrt.f64 #s(literal -1 binary64)))))))
(* re (+ (* -1/16 (* (/ (* (pow im 2) (sqrt 2)) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (* (pow im 3) (sqrt 2)) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (/ (* im (sqrt 2)) (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))))
(*.f64 re (fma.f64 #s(literal 1/32 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (*.f64 im (*.f64 im im))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 5 binary64)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (fma.f64 (*.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im) (sqrt.f64 #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 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (sqrt.f64 #s(literal -1 binary64))))))))
(* -1/2 (* (sqrt re) (* (sqrt -1) (sqrt 2))))
(*.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))) (sqrt.f64 #s(literal -1 binary64)))
(* -1 (* re (+ (* 1/4 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))
(*.f64 (fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (sqrt.f64 #s(literal 2 binary64))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/16 (* (* (pow im 2) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2))))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) (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 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (sqrt.f64 #s(literal 2 binary64))) (*.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 im im)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 #s(literal 2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))))
(* -1 (* re (+ (* -1/16 (* (* (pow im 2) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (* (sqrt -1) (sqrt 2))) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -1) (sqrt 2)))))))))
(-.f64 #s(literal 0 binary64) (*.f64 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 -1 binary64)) (sqrt.f64 #s(literal 2 binary64))) (*.f64 im im))) (fma.f64 #s(literal 1/32 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (*.f64 (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (*.f64 im im)) (sqrt.f64 #s(literal 2 binary64)))) (fma.f64 #s(literal 1/4 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (sqrt.f64 #s(literal 2 binary64))) (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (sqrt.f64 #s(literal 2 binary64))))))))
(* 1/2 (* (sqrt re) (sqrt -1)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64)))
(+ (* 1/4 (* (/ im (sqrt -1)) (sqrt (/ 1 re)))) (* 1/2 (* (sqrt re) (sqrt -1))))
(fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64))))
(+ (* 1/2 (* (sqrt re) (sqrt -1))) (* im (+ (* -1/16 (* (/ im (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/4 (* (sqrt (/ 1 re)) (/ 1 (sqrt -1)))))))
(fma.f64 im (fma.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (*.f64 #s(literal 1/16 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (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 -1 binary64))))
(+ (* 1/2 (* (sqrt re) (sqrt -1))) (* im (+ (* 1/4 (* (sqrt (/ 1 re)) (/ 1 (sqrt -1)))) (* im (+ (* -1/16 (* (sqrt (/ 1 (pow re 3))) (/ 1 (pow (sqrt -1) 3)))) (* 1/32 (* (/ im (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 5))))))))))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal 1/16 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (/.f64 (*.f64 #s(literal 1/32 binary64) im) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 5 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))) (*.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64))))
(* 1/2 (sqrt im))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (sqrt (/ 1 im)))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (*.f64 #s(literal -1/4 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* 1/2 (sqrt (/ 1 im))))))
(*.f64 im (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (fma.f64 (*.f64 #s(literal -1/4 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))))))
(* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (+ (* -1/32 (* (sqrt (/ 1 (pow im 7))) (pow re 3))) (* 1/2 (sqrt (/ 1 im)))))))
(*.f64 im (fma.f64 #s(literal -1/4 binary64) (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (fma.f64 #s(literal -1/32 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/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))))))))
(* -1/2 (* (sqrt im) (pow (sqrt -1) 2)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))
(* -1 (* im (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* 1/2 (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) re)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64)))))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* 1/2 (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64) (fma.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 (-.f64 #s(literal 0 binary64) re) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) re)))))))
(* -1 (* im (+ (* -1/16 (* (sqrt (/ 1 (pow im 5))) (* (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/32 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (pow (sqrt -1) 2)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* 1/2 (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))))
(-.f64 #s(literal 0 binary64) (*.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 (-.f64 #s(literal 0 binary64) re) re)) (fma.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) re)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64) (*.f64 (*.f64 #s(literal 1/32 binary64) (neg.f64 (*.f64 re (*.f64 re re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64))))))))))
(* 1/2 (sqrt im))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 im))
(+ (* -1/4 (* (sqrt (/ 1 im)) re)) (* 1/2 (sqrt im)))
(fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) (*.f64 (*.f64 #s(literal -1/4 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))
(+ (* 1/2 (sqrt im)) (* re (+ (* -1/4 (sqrt (/ 1 im))) (* -1/16 (* (sqrt (/ 1 (pow im 3))) re)))))
(fma.f64 #s(literal 1/2 binary64) (sqrt.f64 im) (*.f64 re (fma.f64 #s(literal -1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (*.f64 (*.f64 re #s(literal -1/16 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))))))
(+ (* 1/2 (sqrt im)) (* re (+ (* -1/4 (sqrt (/ 1 im))) (* re (+ (* -1/16 (sqrt (/ 1 (pow im 3)))) (* -1/32 (* (sqrt (/ 1 (pow im 5))) re)))))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal -1/16 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 #s(literal -1/32 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))))) (*.f64 #s(literal -1/4 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
(* 1/2 (* (sqrt re) (sqrt -1)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64)))
(* re (+ (* 1/4 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1)))))
(*.f64 re (fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* re (+ (* -1/16 (* (/ (pow im 2) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1))))))
(*.f64 re (fma.f64 (*.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(* re (+ (* -1/16 (* (/ (pow im 2) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (/ (pow im 3) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1)))))))
(*.f64 re (fma.f64 #s(literal 1/32 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (/.f64 (*.f64 im (*.f64 im im)) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 5 binary64)))) (fma.f64 (*.f64 #s(literal 1/16 binary64) (/.f64 (*.f64 im im) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))))
(* -1/2 (* (sqrt re) (sqrt -1)))
(*.f64 (*.f64 #s(literal -1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64)))
(* -1 (* re (+ (* 1/4 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1))))))
(*.f64 (fma.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/16 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1)))))))
(*.f64 (fma.f64 #s(literal -1/16 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 im im))) (fma.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/16 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/32 (* (* (pow im 3) (sqrt -1)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/4 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (sqrt -1))))))))
(*.f64 (fma.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 im im)) (sqrt.f64 #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/32 binary64) (sqrt.f64 #s(literal -1 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/4 binary64) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))) (-.f64 #s(literal 0 binary64) re))
(* (sqrt re) (sqrt -1))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -1 binary64)))
(+ (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 re)))) (* (sqrt re) (sqrt -1)))
(fma.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -1 binary64)) (*.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(+ (* im (+ (* -1/8 (* (/ im (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (/ 1 (sqrt -1)))))) (* (sqrt re) (sqrt -1)))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))) (*.f64 (*.f64 #s(literal 1/8 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))) (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -1 binary64))))
(+ (* im (+ (* 1/2 (* (sqrt (/ 1 re)) (/ 1 (sqrt -1)))) (* im (+ (* -1/8 (* (sqrt (/ 1 (pow re 3))) (/ 1 (pow (sqrt -1) 3)))) (* 1/16 (* (/ im (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 5))))))))) (* (sqrt re) (sqrt -1)))
(fma.f64 im (fma.f64 im (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 im (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 5 binary64)))) #s(literal 1/16 binary64) (*.f64 (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal -1 binary64))) #s(literal 1/8 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -1 binary64))))) (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -1 binary64))))
(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/2 (* (sqrt (/ 1 (pow im 3))) re)) (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))))))
(*.f64 im (fma.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (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/2 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* -1/16 (* (sqrt (/ 1 (pow im 7))) (pow re 3)))))))
(*.f64 im (+.f64 (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))) (fma.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 re (*.f64 re re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64))))))))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(sqrt.f64 im)
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))
(*.f64 im (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 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 (pow (sqrt -1) 2)))) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(*.f64 (fma.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 (-.f64 #s(literal 0 binary64) re) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (-.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) re))) (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) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (* (pow re 3) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) (* re (pow (sqrt -1) 2)))) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))
(*.f64 (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (neg.f64 (*.f64 re (*.f64 re re)))) #s(literal 1/16 binary64) (fma.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 (-.f64 #s(literal 0 binary64) re) re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (-.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))) (-.f64 #s(literal 0 binary64) im))
(sqrt im)
(sqrt.f64 im)
(+ (sqrt im) (* -1/2 (* (sqrt (/ 1 im)) re)))
(fma.f64 (*.f64 re #s(literal -1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 im))
(+ (sqrt im) (* re (+ (* -1/2 (sqrt (/ 1 im))) (* -1/8 (* (sqrt (/ 1 (pow im 3))) re)))))
(fma.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64) (*.f64 (*.f64 re #s(literal -1/8 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im 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 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64))) (sqrt.f64 im))
(* (sqrt re) (sqrt -1))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -1 binary64)))
(* re (+ (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1))))
(*.f64 re (fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))))
(* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1)))))
(*.f64 re (fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im im) (sqrt.f64 #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) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))))))
(* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (pow im 3) (pow (sqrt -1) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (/ im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1))))))
(*.f64 re (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (/.f64 (*.f64 im (*.f64 im im)) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 5 binary64)))) #s(literal 1/16 binary64) (fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im im) (sqrt.f64 #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) (/.f64 im (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))))))
(* -1 (* (sqrt re) (sqrt -1)))
(*.f64 (sqrt.f64 re) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64))))
(* -1 (* re (+ (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1)))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/8 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1))))))
(*.f64 (fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (*.f64 (*.f64 #s(literal -1/8 binary64) (sqrt.f64 #s(literal -1 binary64))) (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im))))) (-.f64 #s(literal 0 binary64) re))
(* -1 (* re (+ (* -1/8 (* (* (pow im 2) (sqrt -1)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (* (pow im 3) (sqrt -1)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (* im (sqrt -1)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (sqrt -1)))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 im im))) #s(literal -1/8 binary64) (fma.f64 (*.f64 #s(literal 1/16 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal -1 binary64)) im) (*.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) im)) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))))
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(- im re)
(-.f64 im re)
(- im re)
(-.f64 im re)
(- im re)
(-.f64 im re)
im
(* im (+ 1 (* -1 (/ re im))))
(*.f64 im (-.f64 #s(literal 1 binary64) (/.f64 re im)))
(* im (+ 1 (* -1 (/ re im))))
(*.f64 im (-.f64 #s(literal 1 binary64) (/.f64 re im)))
(* im (+ 1 (* -1 (/ re im))))
(*.f64 im (-.f64 #s(literal 1 binary64) (/.f64 re im)))
im
(* -1 (* im (- (/ re im) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 im (+.f64 #s(literal -1 binary64) (/.f64 re im))))
(* -1 (* im (- (/ re im) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 im (+.f64 #s(literal -1 binary64) (/.f64 re im))))
(* -1 (* im (- (/ re im) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 im (+.f64 #s(literal -1 binary64) (/.f64 re im))))
im
(+ im (* -1 re))
(-.f64 im re)
(+ im (* -1 re))
(-.f64 im re)
(+ im (* -1 re))
(-.f64 im re)
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(* re (- (/ im re) 1))
(*.f64 re (+.f64 #s(literal -1 binary64) (/.f64 im re)))
(* re (- (/ im re) 1))
(*.f64 re (+.f64 #s(literal -1 binary64) (/.f64 im re)))
(* re (- (/ im re) 1))
(*.f64 re (+.f64 #s(literal -1 binary64) (/.f64 im re)))
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(* -1 (* re (+ 1 (* -1 (/ im re)))))
(*.f64 re (+.f64 #s(literal -1 binary64) (/.f64 im re)))
(* -1 (* re (+ 1 (* -1 (/ im re)))))
(*.f64 re (+.f64 #s(literal -1 binary64) (/.f64 im re)))
(* -1 (* re (+ 1 (* -1 (/ im re)))))
(*.f64 re (+.f64 #s(literal -1 binary64) (/.f64 im re)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -4 binary64)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -4 binary64)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -4 binary64)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -4 binary64)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -4 binary64)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -4 binary64)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -4 binary64)))
(* 1/2 (* (sqrt re) (sqrt -4)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -4 binary64)))
(* -1 (* (sqrt re) (sqrt -1)))
(*.f64 (sqrt.f64 re) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64))))
(* -1 (* (sqrt re) (sqrt -1)))
(*.f64 (sqrt.f64 re) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64))))
(* -1 (* (sqrt re) (sqrt -1)))
(*.f64 (sqrt.f64 re) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64))))
(* -1 (* (sqrt re) (sqrt -1)))
(*.f64 (sqrt.f64 re) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -1 binary64))))
(* (sqrt re) (sqrt -4))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -4 binary64)))
(* (sqrt re) (sqrt -4))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -4 binary64)))
(* (sqrt re) (sqrt -4))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -4 binary64)))
(* (sqrt re) (sqrt -4))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -4 binary64)))
(* (sqrt re) (sqrt -4))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -4 binary64)))
(* (sqrt re) (sqrt -4))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -4 binary64)))
(* (sqrt re) (sqrt -4))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -4 binary64)))
(* (sqrt re) (sqrt -4))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -4 binary64)))
(* -2 (* (sqrt re) (sqrt -1)))
(*.f64 (*.f64 #s(literal -2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64)))
(* -2 (* (sqrt re) (sqrt -1)))
(*.f64 (*.f64 #s(literal -2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64)))
(* -2 (* (sqrt re) (sqrt -1)))
(*.f64 (*.f64 #s(literal -2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 binary64)))
(* -2 (* (sqrt re) (sqrt -1)))
(*.f64 (*.f64 #s(literal -2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -1 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))
(* -4 re)
(*.f64 re #s(literal -4 binary64))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* im (sqrt (/ 1 re)))
(*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) 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)
(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)
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(sqrt (/ 1 re))
(sqrt.f64 (/.f64 #s(literal 1 binary64) re))
(* (sqrt (/ 1 re)) (pow (sqrt -1) 2))
(neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* (sqrt (/ 1 re)) (pow (sqrt -1) 2))
(neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* (sqrt (/ 1 re)) (pow (sqrt -1) 2))
(neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* (sqrt (/ 1 re)) (pow (sqrt -1) 2))
(neg.f64 (sqrt.f64 (/.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 re)
(/.f64 #s(literal 1 binary64) re)
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 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 (/ 1 re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))
(*.f64 (*.f64 #s(literal -1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))
(*.f64 (*.f64 #s(literal -1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))
(*.f64 (*.f64 #s(literal -1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 1/2 (* (* im (pow (sqrt -1) 2)) (sqrt (/ 1 re))))
(*.f64 (*.f64 #s(literal -1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 1/2 im)
(*.f64 #s(literal 1/2 binary64) im)
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(+ (* -2 re) (* 2 im))
(fma.f64 re #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) im))
(+ (* -2 re) (* 2 im))
(fma.f64 re #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) im))
(+ (* -2 re) (* 2 im))
(fma.f64 re #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) im))
(* -2 re)
(*.f64 re #s(literal -2 binary64))
(* re (- (* 2 (/ im re)) 2))
(*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64)))
(* re (- (* 2 (/ im re)) 2))
(*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64)))
(* re (- (* 2 (/ im re)) 2))
(*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64)))
(* -2 re)
(*.f64 re #s(literal -2 binary64))
(* -1 (* re (+ 2 (* -2 (/ im re)))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal 2 binary64))))
(* -1 (* re (+ 2 (* -2 (/ im re)))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal 2 binary64))))
(* -1 (* re (+ 2 (* -2 (/ im re)))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 (/.f64 im re) #s(literal -2 binary64) #s(literal 2 binary64))))
(* -2 re)
(*.f64 re #s(literal -2 binary64))
(+ (* -2 re) (* 2 im))
(fma.f64 re #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) im))
(+ (* -2 re) (* 2 im))
(fma.f64 re #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) im))
(+ (* -2 re) (* 2 im))
(fma.f64 re #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) 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 (fma.f64 #s(literal 2 binary64) (/.f64 re im) #s(literal -2 binary64)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (- (* 2 (/ re im)) 2)))
(*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 re im) #s(literal -2 binary64)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (- (* 2 (/ re im)) 2)))
(*.f64 (fma.f64 #s(literal 2 binary64) (/.f64 re im) #s(literal -2 binary64)) (-.f64 #s(literal 0 binary64) im))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(+ (* -1/2 (* (sqrt (/ 1 im)) (/ re (sqrt 2)))) (* 1/2 (* (sqrt im) (sqrt 2))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)) (/.f64 (*.f64 (*.f64 re #s(literal -1/2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))) (sqrt.f64 #s(literal 2 binary64))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* -1/4 (* (sqrt (/ 1 (pow im 3))) (/ re (pow (sqrt 2) 3)))))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)) (*.f64 re (fma.f64 re (*.f64 #s(literal -1/8 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (sqrt.f64 #s(literal 2 binary64)))) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64)) (sqrt.f64 #s(literal 2 binary64))))))
(+ (* 1/2 (* (sqrt im) (sqrt 2))) (* re (+ (* -1/2 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* re (+ (* -1/4 (* (sqrt (/ 1 (pow im 3))) (/ 1 (pow (sqrt 2) 3)))) (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ re (pow (sqrt 2) 5)))))))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)) (*.f64 re (fma.f64 re (fma.f64 #s(literal -1/4 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 re (pow.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 5 binary64)))) (*.f64 #s(literal -1/8 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (sqrt.f64 #s(literal 2 binary64))))) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) #s(literal -1/2 binary64)) (sqrt.f64 #s(literal 2 binary64))))))
(* 1/2 (* (sqrt re) (sqrt -2)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -2 binary64)))
(* re (+ (* 1/2 (* (sqrt (/ 1 re)) (sqrt -2))) (* 1/2 (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3)))))))
(*.f64 (*.f64 re #s(literal 1/2 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (/.f64 im (sqrt.f64 #s(literal -2 binary64))))))
(* re (+ (* -1/4 (* (/ (pow im 2) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (sqrt (/ 1 re)) (sqrt -2))) (* 1/2 (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3))))))))
(*.f64 re (fma.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (/.f64 im (sqrt.f64 #s(literal -2 binary64))))) (*.f64 (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im im) (sqrt.f64 #s(literal -2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
(* re (+ (* -1/4 (* (/ (pow im 2) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/4 (* (/ (pow im 3) (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* (sqrt (/ 1 re)) (sqrt -2))) (* 1/2 (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3)))))))))
(*.f64 re (fma.f64 (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im im) (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/4 binary64) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64))))) (pow.f64 (sqrt.f64 #s(literal -2 binary64)) #s(literal 5 binary64))) (*.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (/.f64 im (sqrt.f64 #s(literal -2 binary64)))))))))
(* -1/2 (* (sqrt re) (* (sqrt -2) (pow (sqrt -1) 2))))
(*.f64 #s(literal -1/2 binary64) (*.f64 (sqrt.f64 re) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -2 binary64)))))
(* -1 (* re (+ (* -1/2 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2)))))))
(*.f64 (-.f64 #s(literal 0 binary64) re) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -2 binary64)))) (*.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))))
(* -1 (* re (+ (* -1/2 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (+ (* -1/4 (* (/ (* (pow im 2) (pow (sqrt -1) 2)) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2))))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -2 binary64)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re))))) (sqrt.f64 #s(literal -2 binary64))) (*.f64 (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) im) (sqrt.f64 #s(literal -2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))))
(* -1 (* re (+ (* -1/2 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (+ (* -1/4 (* (/ (* (pow im 2) (pow (sqrt -1) 2)) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/4 (* (/ (* (pow im 3) (pow (sqrt -1) 2)) (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 7))))) (* 1/2 (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2)))))))))
(-.f64 #s(literal 0 binary64) (*.f64 re (fma.f64 #s(literal -1/4 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -2 binary64)))) (/.f64 (*.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) im) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64))))) (pow.f64 (sqrt.f64 #s(literal -2 binary64)) #s(literal 5 binary64)))) (fma.f64 #s(literal 1/2 binary64) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal -2 binary64)))) (*.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) (-.f64 #s(literal 0 binary64) im)) (sqrt.f64 #s(literal -2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))))))))
(* 1/2 (* (sqrt re) (sqrt -2)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -2 binary64)))
(+ (* 1/2 (* (sqrt re) (sqrt -2))) (* 1/2 (* (/ im (sqrt -2)) (sqrt (/ 1 re)))))
(*.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -2 binary64))) (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -2 binary64)))))
(+ (* 1/2 (* (sqrt re) (sqrt -2))) (* im (+ (* -1/4 (* (/ im (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 re)) (/ 1 (sqrt -2)))))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -2 binary64))) (*.f64 (*.f64 #s(literal 1/8 binary64) (/.f64 im (sqrt.f64 #s(literal -2 binary64)))) (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/2 (* (sqrt (/ 1 re)) (/ 1 (sqrt -2)))) (* im (+ (* -1/4 (* (sqrt (/ 1 (pow re 3))) (/ 1 (pow (sqrt -2) 3)))) (* 1/4 (* (/ im (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 5))))))))))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal 1/4 binary64) (*.f64 im (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (pow.f64 (sqrt.f64 #s(literal -2 binary64)) #s(literal 5 binary64)))) (*.f64 (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal -2 binary64))) #s(literal 1/8 binary64))) (*.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -2 binary64))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) (sqrt.f64 #s(literal -2 binary64))))
(* 1/2 (* (sqrt im) (sqrt 2)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(* im (+ (* -1/2 (* (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 (*.f64 (*.f64 #s(literal -1/2 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (sqrt.f64 #s(literal 2 binary64)))))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (* 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 #s(literal -1/8 binary64) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 re re)) (sqrt.f64 #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (sqrt.f64 #s(literal 2 binary64))))))
(* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* -1/4 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt 2) 5)))) (* 1/2 (* (sqrt (/ 1 im)) (sqrt 2)))))))
(*.f64 im (fma.f64 #s(literal -1/4 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) (*.f64 #s(literal 2 binary64) (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (/.f64 (*.f64 re (*.f64 re re)) (pow.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 5 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 (*.f64 #s(literal -1/2 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (sqrt.f64 #s(literal 2 binary64))))))
(* -1/2 (* (sqrt im) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2)))))))
(*.f64 im (*.f64 #s(literal -1/2 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (/.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64)))))))
(* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (pow (sqrt -1) 2)) (pow (sqrt 2) 3)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2))))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) re) re)) (sqrt.f64 #s(literal 2 binary64))) (*.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (/.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64)))))))))
(* -1 (* im (+ (* -1/4 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (pow (sqrt -1) 2)) (pow (sqrt 2) 3)))) (+ (* 1/4 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (pow (sqrt -1) 2)) (pow (sqrt 2) 5)))) (+ (* 1/2 (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2)))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2)))))))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (/.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) re) re)) (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 7 binary64)))) (/.f64 (neg.f64 (*.f64 re (*.f64 re re))) (pow.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 5 binary64))))))) (-.f64 #s(literal 0 binary64) im))
(* (sqrt im) (sqrt 2))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(+ (* -1 (* (sqrt (/ 1 im)) (/ re (sqrt 2)))) (* (sqrt im) (sqrt 2)))
(fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) re)) (sqrt.f64 #s(literal 2 binary64))))
(+ (* re (+ (* -1 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* -1/2 (* (sqrt (/ 1 (pow im 3))) (/ re (pow (sqrt 2) 3)))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 re (*.f64 #s(literal -1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (sqrt.f64 #s(literal 2 binary64)))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im)))
(+ (* re (+ (* -1 (* (sqrt (/ 1 im)) (/ 1 (sqrt 2)))) (* re (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) (/ 1 (pow (sqrt 2) 3)))) (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ re (pow (sqrt 2) 5)))))))) (* (sqrt im) (sqrt 2)))
(fma.f64 re (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 re (pow.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 5 binary64))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (*.f64 #s(literal 2 binary64) (sqrt.f64 #s(literal 2 binary64))))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 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 (+ (* (sqrt (/ 1 re)) (sqrt -2)) (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3))))))
(*.f64 re (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (/.f64 im (sqrt.f64 #s(literal -2 binary64))))))
(* re (+ (* -1/2 (* (/ (pow im 2) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* (sqrt (/ 1 re)) (sqrt -2)) (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3)))))))
(*.f64 re (fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 im im) (sqrt.f64 #s(literal -2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (/.f64 im (sqrt.f64 #s(literal -2 binary64)))))))
(* re (+ (* -1/2 (* (/ (pow im 2) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* (/ (pow im 3) (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 7))))) (+ (* (sqrt (/ 1 re)) (sqrt -2)) (* (/ im (sqrt -2)) (sqrt (/ 1 (pow re 3))))))))
(*.f64 re (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 (*.f64 im (*.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64))))) (pow.f64 (sqrt.f64 #s(literal -2 binary64)) #s(literal 5 binary64))) (fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 im im) (sqrt.f64 #s(literal -2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -2 binary64)) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (/.f64 im (sqrt.f64 #s(literal -2 binary64))))))))
(* -1 (* (sqrt re) (* (sqrt -2) (pow (sqrt -1) 2))))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -2 binary64)))
(* -1 (* re (+ (* -1 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2))))))
(*.f64 (-.f64 #s(literal 0 binary64) re) (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 im (sqrt.f64 #s(literal -2 binary64))))))
(* -1 (* re (+ (* -1 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (/ (* (pow im 2) (pow (sqrt -1) 2)) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2)))))))
(*.f64 (-.f64 #s(literal 0 binary64) re) (fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) im) (sqrt.f64 #s(literal -2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 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 im (sqrt.f64 #s(literal -2 binary64)))))))
(* -1 (* re (+ (* -1 (* (/ (* im (pow (sqrt -1) 2)) (sqrt -2)) (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (/ (* (pow im 2) (pow (sqrt -1) 2)) (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 5))))) (+ (* -1/2 (* (/ (* (pow im 3) (pow (sqrt -1) 2)) (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 7))))) (* (sqrt (/ 1 re)) (* (sqrt -2) (pow (sqrt -1) 2))))))))
(*.f64 (-.f64 #s(literal 0 binary64) re) (fma.f64 #s(literal -1/2 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (*.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 #s(literal -2 binary64)))) (/.f64 (*.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) im) im) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64))))) (pow.f64 (sqrt.f64 #s(literal -2 binary64)) #s(literal 5 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 im (sqrt.f64 #s(literal -2 binary64)))))))
(* (sqrt re) (sqrt -2))
(*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -2 binary64)))
(+ (* (sqrt re) (sqrt -2)) (* (/ im (sqrt -2)) (sqrt (/ 1 re))))
(fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 im (sqrt.f64 #s(literal -2 binary64))) (*.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -2 binary64))))
(+ (* im (+ (* -1/2 (* (/ im (pow (sqrt -2) 3)) (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (/ 1 (sqrt -2))))) (* (sqrt re) (sqrt -2)))
(fma.f64 (sqrt.f64 re) (sqrt.f64 #s(literal -2 binary64)) (*.f64 im (fma.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 im (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) re)) (sqrt.f64 #s(literal -2 binary64))))))
(+ (* im (+ (* im (+ (* -1/2 (* (sqrt (/ 1 (pow re 3))) (/ 1 (pow (sqrt -2) 3)))) (* 1/2 (* (/ im (pow (sqrt -2) 5)) (sqrt (/ 1 (pow re 5))))))) (* (sqrt (/ 1 re)) (/ 1 (sqrt -2))))) (* (sqrt re) (sqrt -2)))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re re)))) (sqrt.f64 #s(literal -2 binary64))) (*.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) im) (pow.f64 (sqrt.f64 #s(literal -2 binary64)) #s(literal 5 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal -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 (* (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 #s(literal 0 binary64) (/.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 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (* (sqrt (/ 1 im)) (sqrt 2)))))
(*.f64 im (fma.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 re re)) (sqrt.f64 #s(literal 2 binary64))) (/.f64 (*.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64)))))))
(* im (+ (* -1 (* (sqrt (/ 1 (pow im 3))) (/ re (sqrt 2)))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt 2) 3)))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt 2) 5)))) (* (sqrt (/ 1 im)) (sqrt 2))))))
(*.f64 im (fma.f64 #s(literal -1/2 binary64) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (/.f64 (*.f64 re re) (*.f64 #s(literal 2 binary64) (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (/.f64 (*.f64 re (*.f64 re re)) (pow.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 5 binary64))))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (/.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) (* (pow (sqrt -1) 2) (sqrt 2))))
(*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 im))
(* -1 (* im (+ (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2))))))
(*.f64 (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (/.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 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) (pow (sqrt -1) 2)) (pow (sqrt 2) 3)))) (+ (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2)))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) re) re)) (sqrt.f64 #s(literal 2 binary64))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (/.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))))))))
(* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (/ (* (pow re 2) (pow (sqrt -1) 2)) (pow (sqrt 2) 3)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 7))) (/ (* (pow re 3) (pow (sqrt -1) 2)) (pow (sqrt 2) 5)))) (+ (* (sqrt (/ 1 im)) (* (pow (sqrt -1) 2) (sqrt 2))) (* (sqrt (/ 1 (pow im 3))) (/ (* re (pow (sqrt -1) 2)) (sqrt 2))))))))
(*.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) 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 7 binary64)))) (/.f64 (neg.f64 (*.f64 re (*.f64 re re))) (pow.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 5 binary64)))) (fma.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 im (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (/.f64 re (sqrt.f64 #s(literal 2 binary64)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (-.f64 #s(literal 0 binary64) (sqrt.f64 #s(literal 2 binary64))))))) (-.f64 #s(literal 0 binary64) im))
-2
#s(literal -2 binary64)
(- (* 2 (/ im re)) 2)
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
(- (* 2 (/ im re)) 2)
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
(- (* 2 (/ im re)) 2)
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
(* 2 (/ im re))
(*.f64 #s(literal 2 binary64) (/.f64 im re))
(* im (- (* 2 (/ 1 re)) (* 2 (/ 1 im))))
(*.f64 im (+.f64 (/.f64 #s(literal 2 binary64) re) (/.f64 #s(literal -2 binary64) im)))
(* im (- (* 2 (/ 1 re)) (* 2 (/ 1 im))))
(*.f64 im (+.f64 (/.f64 #s(literal 2 binary64) re) (/.f64 #s(literal -2 binary64) im)))
(* im (- (* 2 (/ 1 re)) (* 2 (/ 1 im))))
(*.f64 im (+.f64 (/.f64 #s(literal 2 binary64) re) (/.f64 #s(literal -2 binary64) im)))
(* 2 (/ im re))
(*.f64 #s(literal 2 binary64) (/.f64 im re))
(* -1 (* im (- (* 2 (/ 1 im)) (* 2 (/ 1 re)))))
(*.f64 (+.f64 (/.f64 #s(literal 2 binary64) im) (/.f64 #s(literal -2 binary64) re)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (- (* 2 (/ 1 im)) (* 2 (/ 1 re)))))
(*.f64 (+.f64 (/.f64 #s(literal 2 binary64) im) (/.f64 #s(literal -2 binary64) re)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (- (* 2 (/ 1 im)) (* 2 (/ 1 re)))))
(*.f64 (+.f64 (/.f64 #s(literal 2 binary64) im) (/.f64 #s(literal -2 binary64) re)) (-.f64 #s(literal 0 binary64) im))
(* 2 (/ im re))
(*.f64 #s(literal 2 binary64) (/.f64 im re))
(/ (+ (* -2 re) (* 2 im)) re)
(/.f64 (fma.f64 re #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) im)) re)
(/ (+ (* -2 re) (* 2 im)) re)
(/.f64 (fma.f64 re #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) im)) re)
(/ (+ (* -2 re) (* 2 im)) re)
(/.f64 (fma.f64 re #s(literal -2 binary64) (*.f64 #s(literal 2 binary64) im)) re)
-2
#s(literal -2 binary64)
(- (* 2 (/ im re)) 2)
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
(- (* 2 (/ im re)) 2)
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
(- (* 2 (/ im re)) 2)
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
-2
#s(literal -2 binary64)
(- (* 2 (/ im re)) 2)
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
(- (* 2 (/ im re)) 2)
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64))
(- (* 2 (/ im re)) 2)
(fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 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)

eval113.0ms (1.2%)

Memory
4.0MiB live, 236.7MiB allocated
Compiler

Compiled 19 275 to 2 954 computations (84.7% saved)

prune103.0ms (1.1%)

Memory
13.0MiB live, 253.6MiB allocated
Pruning

16 alts after pruning (5 fresh and 11 done)

PrunedKeptTotal
New1 01011 011
Fresh145
Picked055
Done066
Total1 011161 027
Accuracy
100.0%
Counts
1 027 → 16
Alt Table
Click to see full alt table
StatusAccuracyProgram
27.4%
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
✓27.4%
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
27.4%
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
42.7%
(*.f64 (*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64))
✓52.4%
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re))) (sqrt.f64 #s(literal 2 binary64)))
✓27.4%
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
13.5%
(*.f64 (sqrt.f64 (*.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)))) #s(literal 1/2 binary64))
✓26.9%
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 binary64))) #s(literal 1/2 binary64))
✓42.9%
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
✓50.3%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))))
17.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (/.f64 im re) im)))
✓44.8%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64)))))
✓50.6%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
✓77.5%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re))))
✓52.7%
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re))))
✓5.3%
#s(literal 0 binary64)
Compiler

Compiled 603 to 279 computations (53.7% saved)

regimes74.0ms (0.8%)

Memory
6.5MiB live, 163.7MiB allocated
Counts
35 → 2
Calls
Call 1
Inputs
#s(literal 0 binary64)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 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 re re))))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (/.f64 im re) im)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 im im) re)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im #s(literal 1 binary64)) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64)) im))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64)))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
(*.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 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (/.f64 #s(literal 1 binary64) (sqrt.f64 re))))
(*.f64 im (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.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 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (sqrt.f64 (*.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)))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re))))
(*.f64 im (fma.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1/2 binary64)) (*.f64 (/.f64 (*.f64 #s(literal -1/32 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) im) im)) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
(*.f64 #s(literal 1/2 binary64) (fma.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re))) (*.f64 (*.f64 (*.f64 #s(literal -1/16 binary64) (*.f64 im (*.f64 im im))) (/.f64 (sqrt.f64 #s(literal 2 binary64)) (sqrt.f64 #s(literal 1/2 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/4 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/4 binary64)))))
Outputs
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re))))
Calls

7 calls:

12.0ms
im
10.0ms
(*.f64 im im)
10.0ms
(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
10.0ms
re
10.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))))
Results
AccuracySegmentsBranch
88.0%2re
77.5%1im
89.3%2(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
89.3%2(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
89.7%2(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
89.7%2(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
77.5%1(*.f64 im im)
Compiler

Compiled 69 to 45 computations (34.8% saved)

regimes73.0ms (0.8%)

Memory
-21.4MiB live, 147.8MiB allocated
Counts
31 → 3
Calls
Call 1
Inputs
#s(literal 0 binary64)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 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 re re))))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (/.f64 im re) im)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 im im) re)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im #s(literal 1 binary64)) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64)) im))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -2 binary64)))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (fma.f64 re (+.f64 (/.f64 re im) #s(literal -2 binary64)) (*.f64 im #s(literal 2 binary64)))))
(*.f64 (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) #s(literal 1/2 binary64))
(*.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 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re))) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 (*.f64 (sqrt.f64 (-.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) re)) (sqrt.f64 #s(literal 2 binary64))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 (*.f64 im (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 re)) (sqrt.f64 #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 #s(literal 2 binary64)) (*.f64 (sqrt.f64 #s(literal 1/2 binary64)) im)) (/.f64 #s(literal 1 binary64) (sqrt.f64 re))))
(*.f64 im (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 #s(literal 1/2 binary64))) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.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 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 re (*.f64 re re))) #s(literal -1/4 binary64) (/.f64 #s(literal 1 binary64) re)))))
(*.f64 (sqrt.f64 (*.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)))) #s(literal 1/2 binary64))
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re))))
(*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64)) im))
Calls

7 calls:

15.0ms
im
10.0ms
re
10.0ms
(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
10.0ms
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
9.0ms
(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
Results
AccuracySegmentsBranch
65.7%4im
62.8%3(*.f64 im im)
77.3%3re
74.8%4(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))))
74.8%4(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
75.3%4(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
75.3%4(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
Compiler

Compiled 69 to 45 computations (34.8% saved)

regimes7.0ms (0.1%)

Memory
14.9MiB live, 14.9MiB allocated
Counts
17 → 3
Calls
Call 1
Inputs
#s(literal 0 binary64)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 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 re re))))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (/.f64 im re) im)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 im im) re)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im #s(literal 1 binary64)) (sqrt.f64 re)))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (sqrt.f64 re) im))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (-.f64 im re))) (sqrt.f64 #s(literal 2 binary64)))
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re))))
(*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))
Calls

1 calls:

6.0ms
re
Results
AccuracySegmentsBranch
77.3%3re
Compiler

Compiled 3 to 2 computations (33.3% saved)

regimes7.0ms (0.1%)

Memory
-25.6MiB live, 12.3MiB allocated
Counts
14 → 3
Calls
Call 1
Inputs
#s(literal 0 binary64)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 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 re re))))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
(*.f64 (sqrt.f64 im) (*.f64 (sqrt.f64 #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (sqrt.f64 #s(literal 2 binary64)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 (/.f64 im re) im)))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (*.f64 im im) re)))
(*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im #s(literal 1 binary64)) (sqrt.f64 re)))
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re))))
(*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))
Calls

1 calls:

6.0ms
re
Results
AccuracySegmentsBranch
77.3%3re
Compiler

Compiled 3 to 2 computations (33.3% saved)

regimes4.0ms (0%)

Memory
9.4MiB live, 9.4MiB allocated
Counts
8 → 3
Calls
Call 1
Inputs
#s(literal 0 binary64)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 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 re re))))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)) im)
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re))))
(*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))
Calls

1 calls:

3.0ms
re
Results
AccuracySegmentsBranch
77.3%3re
Compiler

Compiled 3 to 2 computations (33.3% saved)

regimes16.0ms (0.2%)

Memory
2.9MiB live, 39.9MiB allocated
Counts
6 → 3
Calls
Call 1
Inputs
#s(literal 0 binary64)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 (sqrt.f64 (*.f64 re #s(literal -4 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 re re))))
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64))))
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
#s(literal 0 binary64)
Calls

5 calls:

5.0ms
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
3.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))
2.0ms
(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
Results
AccuracySegmentsBranch
52.7%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))))
52.7%1(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
52.7%1(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
52.7%1(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
66.1%3re
Compiler

Compiled 61 to 40 computations (34.4% saved)

regimes14.0ms (0.1%)

Memory
-6.6MiB live, 30.5MiB allocated
Counts
2 → 2
Calls
Call 1
Inputs
#s(literal 0 binary64)
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
Outputs
(*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64))))
#s(literal 0 binary64)
Calls

7 calls:

4.0ms
(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
2.0ms
(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
2.0ms
im
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
re
Results
AccuracySegmentsBranch
50.6%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))))
50.6%1(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
50.6%1(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
50.6%1(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
50.6%1(*.f64 im im)
50.6%1im
52.4%2re
Compiler

Compiled 69 to 45 computations (34.8% saved)

regimes9.0ms (0.1%)

Memory
27.0MiB live, 27.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
re
1.0ms
im
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.3%1(*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))
5.3%1(-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)
5.3%1(*.f64 im im)
5.3%1im
5.3%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.3%1(sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)))
5.3%1re
Compiler

Compiled 69 to 45 computations (34.8% saved)

bsearch0.0ms (0%)

Memory
1.0MiB live, 1.0MiB allocated
Algorithm
1×left-value
Steps
TimeLeftRight
0.0ms
0.0
2.410393547503964e-307
Compiler

Compiled 20 to 17 computations (15% saved)

bsearch34.0ms (0.4%)

Memory
-13.8MiB live, 68.6MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
14.0ms
1.523904715141209e-29
1.7605974529670018e-28
17.0ms
-1.2354985901594002e+47
-1.7424482662716405e+43
Samples
16.0ms178×0valid
4.0ms24×2valid
3.0ms21×1valid
0.0ms1×3valid
Compiler

Compiled 324 to 264 computations (18.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 13.0ms
ival-hypot: 5.0ms (40% of total)
ival-mult: 3.0ms (24% of total)
ival-sqrt: 2.0ms (16% of total)
adjust: 1.0ms (8% of total)
ival-sub: 1.0ms (8% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

bsearch31.0ms (0.3%)

Memory
-0.5MiB live, 78.2MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
15.0ms
1.523904715141209e-29
1.7605974529670018e-28
13.0ms
-1.2354985901594002e+47
-1.7424482662716405e+43
Samples
12.0ms169×0valid
6.0ms32×2valid
3.0ms22×1valid
0.0ms1×3valid
Compiler

Compiled 312 to 258 computations (17.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 14.0ms
ival-hypot: 5.0ms (35.4% of total)
ival-mult: 3.0ms (21.2% of total)
ival-sub: 2.0ms (14.1% of total)
ival-sqrt: 2.0ms (14.1% of total)
adjust: 1.0ms (7.1% of total)
ival-assert: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

bsearch30.0ms (0.3%)

Memory
-11.6MiB live, 68.9MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
14.0ms
1.523904715141209e-29
1.7605974529670018e-28
13.0ms
-1.2354985901594002e+47
-1.7424482662716405e+43
Samples
13.0ms180×0valid
5.0ms26×2valid
2.0ms16×1valid
0.0ms2×3valid
Compiler

Compiled 300 to 246 computations (18% saved)

Precisions
Click to see histograms. Total time spent on operations: 15.0ms
ival-hypot: 6.0ms (41% of total)
ival-mult: 3.0ms (20.5% of total)
ival-sqrt: 3.0ms (20.5% of total)
adjust: 1.0ms (6.8% of total)
ival-sub: 1.0ms (6.8% of total)
ival-assert: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

bsearch30.0ms (0.3%)

Memory
22.9MiB live, 61.9MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
16.0ms
1.523904715141209e-29
1.7605974529670018e-28
12.0ms
-1.2354985901594002e+47
-1.7424482662716405e+43
Samples
10.0ms167×0valid
6.0ms32×2valid
4.0ms23×1valid
0.0ms2×3valid
Compiler

Compiled 300 to 246 computations (18% saved)

Precisions
Click to see histograms. Total time spent on operations: 14.0ms
ival-hypot: 6.0ms (41.4% of total)
ival-mult: 3.0ms (20.7% of total)
ival-sqrt: 2.0ms (13.8% of total)
adjust: 1.0ms (6.9% of total)
ival-sub: 1.0ms (6.9% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

bsearch112.0ms (1.2%)

Memory
-23.7MiB live, 56.1MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
46.0ms
3.174649079320209e+196
3.977038629441299e+204
63.0ms
-617216.568243693
-577.2450853713547
Samples
59.0ms141×0valid
26.0ms52×2valid
8.0ms34×3valid
5.0ms45×1valid
Compiler

Compiled 281 to 250 computations (11% saved)

Precisions
Click to see histograms. Total time spent on operations: 91.0ms
ival-sub: 53.0ms (58.2% of total)
ival-mult: 22.0ms (24.2% of total)
ival-hypot: 10.0ms (11% of total)
ival-sqrt: 4.0ms (4.4% of total)
adjust: 2.0ms (2.2% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

bsearch32.0ms (0.3%)

Memory
26.7MiB live, 65.0MiB allocated
Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
29.0ms
3.174649079320209e+196
3.977038629441299e+204
Samples
9.0ms35×3valid
7.0ms48×1valid
7.0ms38×2valid
2.0ms23×0valid
Compiler

Compiled 137 to 122 computations (10.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 18.0ms
ival-hypot: 8.0ms (45.2% of total)
ival-mult: 4.0ms (22.6% of total)
ival-sqrt: 3.0ms (16.9% of total)
adjust: 2.0ms (11.3% of total)
ival-sub: 2.0ms (11.3% of total)
ival-assert: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

simplify12.0ms (0.1%)

Memory
-11.3MiB live, 27.2MiB allocated
Algorithm
1×egg-herbie
Rules
32×*-commutative_binary64
10×+-commutative_binary64
8×sub-neg_binary64
2×1-exp_binary64
2×neg-sub0_binary64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
074178
197178
2103178
3105178
4106178
Stop Event
1×saturated
Calls
Call 1
Inputs
(if (<=.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #s(literal 0 binary64)) (*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re)))))
(if (<=.f64 re #s(literal -20000000000000000278744233918828198261424128 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 2676089423823675/89202980794122492566142873090593446023921664 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64)) im))))
(if (<=.f64 re #s(literal -24000000000000002315197143559202277752307712 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 1248841731117715/44601490397061246283071436545296723011960832 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 re #s(literal -18000000000000000498457818384021433415106560 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 1828661106279511/44601490397061246283071436545296723011960832 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))))
(if (<=.f64 re #s(literal -19500000000000000333672630035126507049844736 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 5530584809235595/356811923176489970264571492362373784095686656 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))))
(if (<=.f64 re #s(literal -1600 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 1199999999999999963679746655012433991369403930546028351778901011404162181226648906410356060856475022416330148991686588898185628812419341815672620492566878534452283092801479781734181759674005546258661376 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64)))) #s(literal 0 binary64)))
(if (<=.f64 re #s(literal 6000000000000000370782245804499952594018754467297514181671347493134011033555148260471482559568707560810653100796890040135830809758457765038805613621649921658162193381258244930255430467178975524290560 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64)))) #s(literal 0 binary64))
#s(literal 0 binary64)
Outputs
(if (<=.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re) #s(literal 0 binary64)) (*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 (hypot.f64 re im) re)))))
(if (<=.f64 re #s(literal -20000000000000000278744233918828198261424128 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 2676089423823675/89202980794122492566142873090593446023921664 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 #s(literal 1/2 binary64) (*.f64 (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) #s(literal 1 binary64)) im))))
(if (<=.f64 re #s(literal -20000000000000000278744233918828198261424128 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 2676089423823675/89202980794122492566142873090593446023921664 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 #s(literal 1/2 binary64) (*.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(if (<=.f64 re #s(literal -24000000000000002315197143559202277752307712 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 1248841731117715/44601490397061246283071436545296723011960832 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 re #s(literal -24000000000000002315197143559202277752307712 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 1248841731117715/44601490397061246283071436545296723011960832 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (*.f64 im #s(literal 1/2 binary64)))))
(if (<=.f64 re #s(literal -18000000000000000498457818384021433415106560 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 1828661106279511/44601490397061246283071436545296723011960832 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 (/.f64 im (sqrt.f64 re)) #s(literal 1/2 binary64))))
(if (<=.f64 re #s(literal -19500000000000000333672630035126507049844736 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 5530584809235595/356811923176489970264571492362373784095686656 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 #s(literal 2 binary64) (-.f64 im re)))) (*.f64 im (/.f64 #s(literal 1/2 binary64) (sqrt.f64 re)))))
(if (<=.f64 re #s(literal -1600 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 re #s(literal -4 binary64)))) (if (<=.f64 re #s(literal 1199999999999999963679746655012433991369403930546028351778901011404162181226648906410356060856475022416330148991686588898185628812419341815672620492566878534452283092801479781734181759674005546258661376 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64)))) #s(literal 0 binary64)))
(if (<=.f64 re #s(literal 6000000000000000370782245804499952594018754467297514181671347493134011033555148260471482559568707560810653100796890040135830809758457765038805613621649921658162193381258244930255430467178975524290560 binary64)) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (*.f64 im #s(literal 2 binary64)))) #s(literal 0 binary64))
#s(literal 0 binary64)

soundness778.0ms (8.2%)

Memory
18.9MiB live, 855.0MiB allocated
Rules
11 848×accelerator-lowering-fma.f32
11 848×accelerator-lowering-fma.f64
9 012×accelerator-lowering-fma.f32
9 012×accelerator-lowering-fma.f64
8 470×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
07636049
125925885
266605863
082935615
034151
1158140
01017112
05513257
118143103
263803088
081982913
027130
1111122
2695117
36513117
0833792
01265
14865
236665
3418165
0838138
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×iter limit
1×node limit
1×iter limit
1×node limit
Compiler

Compiled 429 to 272 computations (36.6% saved)

preprocess143.0ms (1.5%)

Memory
-29.8MiB live, 177.1MiB allocated
Remove

(abs im)

Compiler

Compiled 456 to 210 computations (53.9% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...