math.abs on complex

Time bar (total: 4.3s)

analyze0.0ms (0%)

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

Compiled 10 to 5 computations (50% saved)

sample815.0ms (18.8%)

Memory
-31.6MiB live, 652.3MiB allocated
Samples
577.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 306.0ms
ival-hypot: 298.0ms (97.3% of total)
ival-true: 6.0ms (2% of total)
ival-assert: 3.0ms (1% of total)
Bogosity

preprocess17.0ms (0.4%)

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

Useful iterations: 0 (0.0ms)

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

(abs im)

(abs re)

(sort re im)

explain84.0ms (1.9%)

Memory
-10.2MiB live, 182.5MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1230-2(1.0966403012187353e-194 5.498536716786759e-162)(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
00-0-(+.f64 (*.f64 re re) (*.f64 im im))
00-0-(*.f64 re re)
00-0-re
00-0-(*.f64 im im)
00-0-im
Explanations
Click to see full explanations table
OperatorSubexpressionExplanationCount
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))oflow-rescue1120
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow112
↳(*.f64 re re)overflow15
↳(*.f64 im im)overflow112
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue90
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow9
↳(*.f64 re re)underflow109
↳(*.f64 im im)underflow9
Confusion
Predicted +Predicted -
+1212
-0133
Precision
1.0
Recall
0.983739837398374
Confusion?
Predicted +Predicted MaybePredicted -
+12102
-00133
Precision?
1.0
Recall?
0.983739837398374
Freqs
test
numberfreq
0135
1121
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
31.0ms512×0valid
Compiler

Compiled 70 to 28 computations (60% saved)

Precisions
Click to see histograms. Total time spent on operations: 18.0ms
ival-hypot: 8.0ms (44% of total)
ival-mult: 7.0ms (38.5% of total)
ival-add: 2.0ms (11% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.5MiB live, 0.5MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

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

Compiled 10 to 6 computations (40% saved)

simplify4.0ms (0.1%)

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

Found 4 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(*.f64 im im)
✓cost-diff0
(*.f64 re re)
✓cost-diff0
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
✓cost-diff128
(+.f64 (*.f64 re re) (*.f64 im im))
Rules
4×lower-hypot.f32
4×lower-hypot.f64
4×lower-fma.f64
4×lift-*.f64
4×lower-fma.f32
Iterations

Useful iterations: 0 (0.0ms)

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

localize28.0ms (0.6%)

Memory
-14.9MiB live, 36.2MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(*.f64 re re)
✓accuracy100.0%
(*.f64 im im)
✓accuracy100.0%
(+.f64 (*.f64 re re) (*.f64 im im))
✓accuracy55.5%
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
Samples
21.0ms256×0valid
Compiler

Compiled 25 to 8 computations (68% saved)

Precisions
Click to see histograms. Total time spent on operations: 8.0ms
ival-hypot: 4.0ms (48.5% of total)
ival-mult: 3.0ms (36.4% of total)
ival-add: 1.0ms (12.1% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series6.0ms (0.1%)

Memory
-26.5MiB live, 12.7MiB allocated
Counts
4 → 72
Calls
Call 1
Inputs
#<alt (+.f64 (*.f64 re re) (*.f64 im im))>
#<alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))>
#<alt (*.f64 re re)>
#<alt (*.f64 im im)>
Outputs
#<alt (pow im 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow re 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
Calls

18 calls:

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

simplify448.0ms (10.3%)

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

Useful iterations: 0 (0.0ms)

IterNodesCost
0104620
1296620
2956618
33681584
46441582
08069530
Stop Event
1×iter limit
1×node limit
Counts
72 → 68
Calls
Call 1
Inputs
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
Outputs
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 im im)) #s(literal 1/2 binary64)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) re)) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (/.f64 (*.f64 im (*.f64 im (*.f64 (*.f64 im im) #s(literal -1/8 binary64)))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) re)) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) re)) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -1/2 binary64) (*.f64 im (/.f64 im re)) (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1 binary64)) (*.f64 #s(literal -1/2 binary64) (*.f64 im (/.f64 im re))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1 binary64))) re (*.f64 #s(literal -1/2 binary64) (*.f64 im (/.f64 im re))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) re)) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im (/.f64 im re)) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/8 binary64) (*.f64 re re)) #s(literal 1/2 binary64)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 im (*.f64 (/.f64 im (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64)) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) (/.f64 re im)) re (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal -1 binary64)) (*.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal -1 binary64))) im (*.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re im)))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)

rewrite612.0ms (14.1%)

Memory
34.4MiB live, 473.3MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 720×lower-fma.f64
5 720×lower-fma.f32
4 038×lower-/.f64
4 038×lower-/.f32
3 184×lower-*.f32
Iterations

Useful iterations: 0 (0.0ms)

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

eval81.0ms (1.9%)

Memory
2.5MiB live, 78.3MiB allocated
Compiler

Compiled 14 217 to 959 computations (93.3% saved)

prune99.0ms (2.3%)

Memory
-29.5MiB live, 90.9MiB allocated
Pruning

5 alts after pruning (5 fresh and 0 done)

PrunedKeptTotal
New3085313
Fresh000
Picked101
Done000
Total3095314
Accuracy
100.0%
Counts
314 → 5
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶55.5%
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
▶4.6%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
▶54.5%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
▶99.6%
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
▶1.9%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Compiler

Compiled 78 to 44 computations (43.6% saved)

simplify10.0ms (0.2%)

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

Found 15 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(*.f64 re re)
✓cost-diff0
(fma.f64 im im (*.f64 re re))
✓cost-diff0
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓cost-diff0
(*.f64 re re)
✓cost-diff0
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
✓cost-diff0
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
✓cost-diff0
(*.f64 im im)
✓cost-diff0
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
✓cost-diff0
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
✓cost-diff0
(neg.f64 re)
✓cost-diff0
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
✓cost-diff0
(*.f64 re #s(literal 1/2 binary64))
✓cost-diff0
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
✓cost-diff0
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
✓cost-diff0
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
Rules
68×lower-fma.f32
64×lower-fma.f64
60×lower-+.f64
60×lower-+.f32
48×lower-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
021122
031116
143116
252116
360116
467116
571116
6101116
7127116
8136116
9142116
10142116
0142104
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
re
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(*.f64 re #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
im
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
re
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(*.f64 im im)
im
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
re
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re
Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
re
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(*.f64 re #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
im
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
re
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(*.f64 im im)
im
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
re
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
im
(*.f64 re re)
re

localize156.0ms (3.6%)

Memory
-14.1MiB live, 104.2MiB allocated
Localize:

Found 15 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(fma.f64 im im (*.f64 re re))
✓accuracy100.0%
(*.f64 re re)
✓accuracy55.5%
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓accuracy100.0%
(*.f64 re re)
✓accuracy55.5%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
✓accuracy13.7%
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
✓accuracy100.0%
(*.f64 im im)
✓accuracy98.9%
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
✓accuracy55.5%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
✓accuracy100.0%
(neg.f64 re)
✓accuracy1.9%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
✓accuracy100.0%
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
✓accuracy100.0%
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
✓accuracy100.0%
(*.f64 re #s(literal 1/2 binary64))
✓accuracy99.6%
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
Samples
97.0ms256×0valid
Compiler

Compiled 99 to 16 computations (83.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 39.0ms
ival-hypot: 26.0ms (66.5% of total)
ival-mult: 6.0ms (15.4% of total)
ival-add: 4.0ms (10.2% of total)
ival-div: 2.0ms (5.1% of total)
ival-neg: 1.0ms (2.6% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series11.0ms (0.3%)

Memory
23.3MiB live, 23.4MiB allocated
Counts
14 → 288
Calls
Call 1
Inputs
#<alt #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))>
#<alt (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)>
#<alt (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)>
#<alt (*.f64 re #s(literal 1/2 binary64))>
#<alt #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))>
#<alt (neg.f64 re)>
#<alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))>
#<alt #s(approx (+ (* re re) (* im im)) (*.f64 im im))>
#<alt (*.f64 im im)>
#<alt (sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))>
#<alt #s(approx (+ (* re re) (* im im)) (*.f64 re re))>
#<alt (*.f64 re re)>
#<alt (sqrt.f64 (fma.f64 im im (*.f64 re re)))>
#<alt (fma.f64 im im (*.f64 re 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 im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt im>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<alt (* 1/2 re)>
#<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 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 im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))>
#<alt (pow 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 (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 im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))>
#<alt (pow 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 (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 re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))>
#<alt (pow re 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
Calls

72 calls:

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

simplify1.0s (23.3%)

Memory
-37.0MiB live, 652.9MiB allocated
Algorithm
1×egg-herbie
Rules
16 212×lower-fma.f64
16 212×lower-fma.f32
4 244×lower-*.f64
4 244×lower-*.f32
2 514×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01182896
13292896
210282886
339622716
475232716
082792484
Stop Event
1×iter limit
1×node limit
Counts
288 → 265
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))))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
(* -1 re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(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)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(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)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 im im)) #s(literal 1/2 binary64)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) 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 (*.f64 re (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im (/.f64 im re)) (fma.f64 #s(literal -1/8 binary64) (*.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.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)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal -1/8 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 #s(literal 1/8 binary64) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) im) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(-.f64 (*.f64 im (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 im im)) #s(literal 1/2 binary64)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) 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 (*.f64 re (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im (/.f64 im re)) (fma.f64 #s(literal -1/8 binary64) (*.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.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)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal -1/8 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 #s(literal 1/8 binary64) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) im) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(-.f64 (*.f64 im (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
(* -1 re)
(neg.f64 re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 im im)) #s(literal 1/2 binary64)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) 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 (*.f64 re (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im (/.f64 im re)) (fma.f64 #s(literal -1/8 binary64) (*.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.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)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal -1/8 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 #s(literal 1/8 binary64) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) im) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(-.f64 (*.f64 im (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(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)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 im im)) #s(literal 1/2 binary64)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) 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 (*.f64 re (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im (/.f64 im re)) (fma.f64 #s(literal -1/8 binary64) (*.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.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)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal -1/8 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 #s(literal 1/8 binary64) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) im) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(-.f64 (*.f64 im (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(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)
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im (/.f64 im re)) (fma.f64 #s(literal -1/8 binary64) (*.f64 im (/.f64 im (*.f64 re re))) #s(literal 1/2 binary64)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.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)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal -1/8 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 #s(literal 1/8 binary64) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) im) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(-.f64 (*.f64 im (fma.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 im im)) #s(literal 1/2 binary64)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) 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 (*.f64 re (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (*.f64 #s(literal 1/8 binary64) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re))))))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) re) re))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))

rewrite294.0ms (6.8%)

Memory
0.2MiB live, 551.3MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
6 026×lower-fma.f32
6 022×lower-fma.f64
3 966×lower-*.f32
3 960×lower-*.f64
2 630×lower-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
021111
031105
190105
2561105
36410105
0807293
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
14 → 353
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(*.f64 re #s(literal 1/2 binary64))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(neg.f64 re)
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(*.f64 im im)
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(*.f64 re re)
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(+.f64 im (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im))
(+.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)
(+.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)))
(-.f64 (/.f64 (*.f64 im im) (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))) (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(fma.f64 re (/.f64 (/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(fma.f64 im #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im))
(fma.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 re im) re) im)
(fma.f64 #s(literal 1/2 binary64) (*.f64 re (/.f64 re im)) im)
(fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im)
(fma.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) re im)
(fma.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (/.f64 (*.f64 re (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 (*.f64 re re) (/.f64 (/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (/.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(fma.f64 (*.f64 re #s(literal -1/2 binary64)) (*.f64 (/.f64 #s(literal -1 binary64) im) re) im)
(fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re (neg.f64 im)) im)
(fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(fma.f64 #s(literal 1 binary64) im (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)
(fma.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)
(fma.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 re (/.f64 #s(literal 2 binary64) re)) im)
(fma.f64 #s(literal -1 binary64) (neg.f64 im) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im))
(fma.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(fma.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) im) im)
(fma.f64 (/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (/.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(fma.f64 (*.f64 re (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im)) (/.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)
(fma.f64 (/.f64 re im) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) re)) im)
(fma.f64 (/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (*.f64 im im)) (/.f64 re (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(fma.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)
(fma.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) #s(literal -1 binary64)) (/.f64 re im) im)
(fma.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)) (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im))
(fma.f64 (/.f64 re (neg.f64 im)) (*.f64 re #s(literal -1/2 binary64)) im)
(fma.f64 (/.f64 re #s(literal 1 binary64)) (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(fma.f64 (/.f64 re (/.f64 im re)) #s(literal 1/2 binary64) im)
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (fma.f64 im (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(neg.f64 (/.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (neg.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)))))
(neg.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))))
(neg.f64 (/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)))
(/.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))
(/.f64 (neg.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (neg.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im))
(/.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)) (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) #s(literal 9 binary64))) (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)) (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (fma.f64 (*.f64 im im) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)) (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) #s(literal 9 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im im) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (neg.f64 (neg.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)))) (neg.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)))
(/.f64 (neg.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)))) (neg.f64 (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) (fma.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (*.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)))) (*.f64 (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)) (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)))) (+.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) (/.f64 (*.f64 im im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) #s(literal 1 binary64)) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)) (pow.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)))) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im))) (fma.f64 (*.f64 im im) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im))) (fma.f64 im im (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)))) #s(literal -1 binary64))
(*.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im))))
(*.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (/.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im)))
(*.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))))
(*.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)) (*.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)))))
(*.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)) (/.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))))
(*.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)))
(*.f64 (neg.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)))))
(*.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im))) (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))
(*.f64 (/.f64 #s(literal -1 binary64) (fma.f64 re (/.f64 (*.f64 re #s(literal -1/2 binary64)) im) im)) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)))
(*.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))))
(*.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))) (*.f64 im (*.f64 (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)) (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))))) (/.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (fma.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))) (-.f64 (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im))) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 (*.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64))) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) im) im) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)))))) (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im (+.f64 im (/.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) im)))))
(*.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im im)))) (fma.f64 im (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im) (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 1/4 binary64)) (*.f64 im im))))
(exp.f64 (*.f64 (log.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 im)) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(neg.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im)))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64)))))
(/.f64 re (*.f64 im #s(literal 2 binary64)))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 (*.f64 re #s(literal -1/2 binary64)) (neg.f64 im))
(/.f64 #s(literal 1 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 2 binary64) re))
(/.f64 #s(literal -1 binary64) (/.f64 im (*.f64 re #s(literal -1/2 binary64))))
(/.f64 (*.f64 (*.f64 re #s(literal -1/2 binary64)) #s(literal 1 binary64)) (neg.f64 im))
(/.f64 (*.f64 #s(literal 1 binary64) (*.f64 re #s(literal -1/2 binary64))) (neg.f64 im))
(/.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) #s(literal -1 binary64)) im)
(pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(*.f64 #s(literal 1/2 binary64) (*.f64 (neg.f64 re) (/.f64 #s(literal -1 binary64) im)))
(*.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im))
(*.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) #s(literal 1 binary64))
(*.f64 (neg.f64 re) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal -1 binary64) im)))
(*.f64 (neg.f64 re) (/.f64 #s(literal 1/2 binary64) (neg.f64 im)))
(*.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) im))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 re #s(literal 1/2 binary64)) im))
(*.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 re #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) re)))
(*.f64 #s(literal -1 binary64) (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) re)
(*.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 re) im))
(*.f64 #s(literal -1/2 binary64) (*.f64 re (/.f64 #s(literal -1 binary64) im)))
(*.f64 #s(literal -1/2 binary64) (/.f64 re (neg.f64 im)))
(*.f64 (/.f64 #s(literal -1 binary64) im) (*.f64 re #s(literal -1/2 binary64)))
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(*.f64 (*.f64 #s(literal 1 binary64) (*.f64 re #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im))
(*.f64 (/.f64 (neg.f64 re) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 (pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1/2 binary64)))
(-.f64 #s(literal 0 binary64) (*.f64 re #s(literal -1/2 binary64)))
(neg.f64 (*.f64 re #s(literal -1/2 binary64)))
(*.f64 re #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) re)
(*.f64 #s(literal 1/2 binary64) (neg.f64 (neg.f64 re)))
(*.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
(*.f64 (neg.f64 re) #s(literal -1/2 binary64))
(*.f64 #s(literal 1 binary64) (*.f64 re #s(literal 1/2 binary64)))
(*.f64 #s(literal -1 binary64) (*.f64 re #s(literal -1/2 binary64)))
(*.f64 #s(literal -1/2 binary64) (neg.f64 re))
(*.f64 (neg.f64 (neg.f64 re)) #s(literal 1/2 binary64))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
(+.f64 (neg.f64 re) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (neg.f64 re))
(-.f64 #s(literal 0 binary64) re)
(-.f64 (/.f64 #s(literal 0 binary64) (*.f64 re re)) (/.f64 (*.f64 re (*.f64 re re)) (*.f64 re re)))
(-.f64 (/.f64 #s(literal 0 binary64) re) (/.f64 (*.f64 re re) re))
(fma.f64 re #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) re #s(literal 0 binary64))
(fma.f64 (neg.f64 (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (*.f64 re re)) (/.f64 #s(literal 1 binary64) re) #s(literal 0 binary64))
(neg.f64 re)
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 re re) (neg.f64 (*.f64 re (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 re (neg.f64 (*.f64 re re))))
(/.f64 (neg.f64 (*.f64 re (*.f64 re re))) (*.f64 re re))
(/.f64 (neg.f64 (*.f64 re re)) re)
(/.f64 (neg.f64 (neg.f64 (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 re re)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (neg.f64 re) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 (neg.f64 re) (neg.f64 re)) (*.f64 #s(literal 0 binary64) (neg.f64 re)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 re) (neg.f64 re))) (-.f64 #s(literal 0 binary64) (neg.f64 re)))
(/.f64 (neg.f64 (neg.f64 (*.f64 re re))) (neg.f64 re))
(pow.f64 (/.f64 (*.f64 re re) (neg.f64 (*.f64 re (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (/.f64 re (neg.f64 (*.f64 re re))) #s(literal -1 binary64))
(*.f64 re #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) re)
(*.f64 (neg.f64 (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re)))
(*.f64 (neg.f64 (*.f64 re re)) (/.f64 #s(literal 1 binary64) re))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
(pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(approx (+ (* re re) (* im im)) (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)) #s(literal 1/4 binary64)))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 2 binary64))
(*.f64 im im)
(*.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
(pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(approx (+ (* re re) (* im im)) (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))) #s(literal 1/2 binary64))
(*.f64 (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)) #s(literal 1/4 binary64)))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
(+.f64 (*.f64 re re) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 re re))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 re)))
(fma.f64 re re #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) #s(literal 0 binary64))
(/.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (*.f64 re re)))
(/.f64 (+.f64 #s(literal 0 binary64) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (+.f64 #s(literal 0 binary64) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 #s(literal 0 binary64) (*.f64 re re)))))
(/.f64 (fma.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)) #s(literal 0 binary64)) (fma.f64 re (*.f64 re (*.f64 re re)) (-.f64 #s(literal 0 binary64) (*.f64 (*.f64 re re) #s(literal 0 binary64)))))
(/.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) #s(literal 0 binary64)) (-.f64 (*.f64 re re) #s(literal 0 binary64)))
(pow.f64 re #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 2 binary64))
(*.f64 re re)
(*.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(hypot.f64 re im)
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (sqrt.f64 (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal -1 binary64))
(*.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(+.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im 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))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 (*.f64 im im) (/.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(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 (*.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 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 (*.f64 im (*.f64 im im)) (/.f64 im (*.f64 (+.f64 re im) (-.f64 im re))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)) (*.f64 re re))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(fma.f64 (/.f64 re (+.f64 re im)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 re im)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 re im)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 im (+.f64 re im)) (/.f64 (*.f64 im (*.f64 im im)) (-.f64 im re)) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im im) (+.f64 re im)) (/.f64 (*.f64 im im) (-.f64 im re)) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im im)) (+.f64 re im)) (/.f64 im (-.f64 im re)) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 re re (*.f64 im im)) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re re (*.f64 im im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(neg.f64 (/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(neg.f64 (/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (*.f64 (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))) (neg.f64 (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (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 (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.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 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))))) (fma.f64 im (/.f64 (*.f64 im (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) #s(literal 1 binary64)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1 binary64)) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1 binary64)) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 im im) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re)))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 im (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (-.f64 re im))
(/.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)) (-.f64 im re))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 re re (*.f64 im im)))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re re (*.f64 im im)))
(*.f64 (/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.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 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 re re) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (fma.f64 (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)))))) (-.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (fma.f64 im (*.f64 im im) (*.f64 re (*.f64 re re))) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 re (*.f64 re re))))) (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))

eval76.0ms (1.8%)

Memory
36.3MiB live, 230.5MiB allocated
Compiler

Compiled 15 028 to 1 067 computations (92.9% saved)

prune61.0ms (1.4%)

Memory
-34.5MiB live, 135.8MiB allocated
Pruning

5 alts after pruning (0 fresh and 5 done)

PrunedKeptTotal
New6440644
Fresh000
Picked055
Done000
Total6445649
Accuracy
100.0%
Counts
649 → 5
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓55.5%
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
✓4.6%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 re re)))
✓54.5%
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
✓99.6%
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
✓1.9%
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Compiler

Compiled 78 to 37 computations (52.6% saved)

regimes17.0ms (0.4%)

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

6 calls:

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

Compiled 35 to 21 computations (40% saved)

regimes13.0ms (0.3%)

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

6 calls:

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

Compiled 35 to 21 computations (40% saved)

regimes12.0ms (0.3%)

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

6 calls:

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

Compiled 35 to 21 computations (40% saved)

regimes9.0ms (0.2%)

Memory
-14.4MiB live, 25.0MiB allocated
Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

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

6 calls:

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

Compiled 35 to 21 computations (40% saved)

simplify6.0ms (0.1%)

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

Useful iterations: 0 (0.0ms)

IterNodesCost
01947
12447
22647
32747
Stop Event
1×saturated
Calls
Call 1
Inputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
Outputs
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(sqrt.f64 #s(approx (+ (* re re) (* im im)) (*.f64 im im)))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))

soundness409.0ms (9.4%)

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

Useful iterations: 0 (0.0ms)

IterNodesCost
0621
01021
12921
219621
3178821
0862415
0104620
1296620
2956618
33681584
46441582
08069530
Stop Event
1×done
1×iter limit
1×node limit
1×iter limit
1×node limit
1×iter limit
Compiler

Compiled 63 to 33 computations (47.6% saved)

preprocess60.0ms (1.4%)

Memory
22.1MiB live, 142.6MiB allocated
Compiler

Compiled 138 to 72 computations (47.8% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...