math.log/1 on complex, real part

Time bar (total: 4.4s)

analyze44.0ms (1%)

Memory
-24.0MiB live, 91.8MiB allocated
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.9%0.1%0%0%0%0
0%0%99.9%0.1%0%0%0%1
0%0%99.9%0.1%0%0%0%2
0%0%99.9%0.1%0%0%0%3
0%0%99.9%0.1%0%0%0%4
18.8%18.7%81.2%0.1%0%0%0%5
34.4%34.3%65.6%0.1%0%0%0%6
54.7%54.6%45.3%0.1%0%0%0%7
64.8%64.8%35.1%0.1%0%0%0%8
76.2%76.1%23.8%0.1%0%0%0%9
81.8%81.8%18.1%0.1%0%0%0%10
87.8%87.7%12.2%0.1%0%0%0%11
90.8%90.7%9.2%0.1%0%0%0%12
Compiler

Compiled 11 to 6 computations (45.5% saved)

sample687.0ms (15.5%)

Memory
38.9MiB live, 1 432.3MiB allocated
Samples
512.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 289.0ms
ival-hypot: 153.0ms (52.9% of total)
ival-log: 127.0ms (43.9% of total)
ival-true: 6.0ms (2.1% of total)
ival-assert: 3.0ms (1% of total)
Bogosity

preprocess17.0ms (0.4%)

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

Useful iterations: 0 (0.0ms)

IterNodesCost
02256
14056
28256
315056
420956
522456
622656
079
189
084
Stop Event
1×iter limit
1×saturated
1×saturated
Calls
Call 1
Inputs
(log (sqrt (+ (* re re) (* im im))))
Outputs
(log (sqrt (+ (* re re) (* im im))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
Call 2
Inputs
(log (sqrt (+ (* re re) (* im im))))
(log (sqrt (+ (* (neg re) (neg re)) (* im im))))
(log (sqrt (+ (* re re) (* (neg im) (neg im)))))
(neg (log (sqrt (+ (* (neg re) (neg re)) (* im im)))))
(neg (log (sqrt (+ (* re re) (* (neg im) (neg im))))))
(log (sqrt (+ (* im im) (* re re))))
Outputs
(log (sqrt (+ (* re re) (* im im))))
(log (sqrt (+ (* (neg re) (neg re)) (* im im))))
(log (sqrt (+ (* re re) (* im im))))
(log (sqrt (+ (* re re) (* (neg im) (neg im)))))
(log (sqrt (+ (* re re) (* im im))))
(neg (log (sqrt (+ (* (neg re) (neg re)) (* im im)))))
(neg (log (sqrt (+ (* re re) (* im im)))))
(neg (log (sqrt (+ (* re re) (* (neg im) (neg im))))))
(neg (log (sqrt (+ (* re re) (* im im)))))
(log (sqrt (+ (* im im) (* re re))))
(log (sqrt (+ (* re re) (* im im))))
Symmetry

(abs re)

(abs im)

(sort re im)

explain168.0ms (3.8%)

Memory
-2.1MiB live, 270.4MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1260-3(8.065796378933607e-258 2.3071401778046493e-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-(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.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-rescue1050
↳(+.f64 (*.f64 re re) (*.f64 im im))overflow105
↳(*.f64 re re)overflow13
↳(*.f64 im im)overflow105
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue180
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow18
↳(*.f64 re re)underflow106
↳(*.f64 im im)underflow18
Confusion
Predicted +Predicted -
+1233
-0130
Precision
1.0
Recall
0.9761904761904762
Confusion?
Predicted +Predicted MaybePredicted -
+12303
-00130
Precision?
1.0
Recall?
0.9761904761904762
Freqs
test
numberfreq
0133
1123
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
98.0ms512×0valid
Compiler

Compiled 90 to 32 computations (64.4% saved)

Precisions
Click to see histograms. Total time spent on operations: 83.0ms
ival-hypot: 68.0ms (81.5% of total)
ival-mult: 7.0ms (8.4% of total)
ival-log: 6.0ms (7.2% of total)
ival-add: 2.0ms (2.4% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.4MiB live, 0.4MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

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

Compiled 11 to 7 computations (36.4% saved)

simplify4.0ms (0.1%)

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

Found 4 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(*.f64 re re)
✓cost-diff0
(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))
✓cost-diff0
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
✓cost-diff128
(+.f64 (*.f64 re re) (*.f64 im im))
Rules
4×+-lowering-+.f64
4×*-lowering-*.f32
4×accelerator-lowering-hypot.f32
4×*-lowering-*.f64
4×+-lowering-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0732
1832
0821
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(log (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(* re re)
re
(* im im)
im
Outputs
(log (sqrt (+ (* re re) (* im im))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(sqrt (+ (* re re) (* im im)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(+ (* re re) (* im im))
(fma.f64 re re (*.f64 im im))
(* re re)
(*.f64 re re)
re
(* im im)
(*.f64 im im)
im

localize36.0ms (0.8%)

Memory
-10.3MiB live, 70.2MiB allocated
Localize:

Found 4 expressions of interest:

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

Compiled 34 to 9 computations (73.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 16.0ms
ival-hypot: 9.0ms (54.8% of total)
ival-log: 3.0ms (18.3% of total)
ival-mult: 3.0ms (18.3% of total)
ival-add: 1.0ms (6.1% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series10.0ms (0.2%)

Memory
-15.9MiB live, 23.3MiB allocated
Counts
5 → 96
Calls
Call 1
Inputs
#<alt (+ (* re re) (* im im))>
#<alt (log (sqrt (+ (* re re) (* im im))))>
#<alt (sqrt (+ (* re re) (* im im)))>
#<alt (* re re)>
#<alt (* im im)>
Outputs
#<alt (pow im 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (log re)>
#<alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (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 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

24 calls:

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

rewrite345.0ms (7.8%)

Memory
-14.8MiB live, 751.5MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 744×accelerator-lowering-fma.f32
5 744×accelerator-lowering-fma.f64
3 222×*-lowering-*.f32
3 222×*-lowering-*.f64
3 034×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0730
12630
219430
3179530
0815119
Stop Event
1×iter limit
1×node limit
Counts
5 → 260
Calls
Call 1
Inputs
(+ (* re re) (* im im))
(log (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* re re) (* im im)))
(* re re)
(* im im)
Outputs
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(exp.f64 (log.f64 (fma.f64 re re (*.f64 im im))))
(exp.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (*.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 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 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 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (/.f64 (*.f64 (*.f64 (*.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)))) (*.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 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))) (/.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (/.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(-.f64 (/.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (/.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 re (+.f64 re im)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 re im)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 re im)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re re (*.f64 im im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 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))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 re re (*.f64 im im))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 re re (*.f64 im im))))
(/.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 (*.f64 (*.f64 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 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (exp.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (*.f64 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 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (-.f64 (*.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 (*.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 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))))))) (neg.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (neg.f64 (*.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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.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 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 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 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re (*.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 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (-.f64 re im))
(/.f64 (exp.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (exp.f64 (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (exp.f64 (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (exp.f64 (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (exp.f64 (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (exp.f64 (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (exp.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 #s(literal 0 binary64) (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (*.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))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (-.f64 #s(literal 0 binary64) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (-.f64 #s(literal 0 binary64) (*.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) (-.f64 #s(literal 0 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 #s(literal 0 binary64) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 #s(literal 0 binary64) (*.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 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (-.f64 #s(literal 0 binary64) (*.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 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (*.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)))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 #s(literal 0 binary64) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (*.f64 re (*.f64 re (*.f64 re re)))) (-.f64 re im)) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (+.f64 re im)))) (*.f64 (-.f64 #s(literal 0 binary64) (*.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)) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (-.f64 re im) (-.f64 #s(literal 0 binary64) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (-.f64 re im) (-.f64 #s(literal 0 binary64) (*.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 (*.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 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (*.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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (neg.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (*.f64 (*.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 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))) (neg.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))) (neg.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (neg.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (neg.f64 (-.f64 re im)))
(/.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (pow.f64 (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 (*.f64 (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1 binary64))
(*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal -1 binary64)))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (*.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 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.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 re (*.f64 re (*.f64 re re)) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)))))
(*.f64 (pow.f64 (/.f64 (+.f64 re im) (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.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 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(*.f64 (exp.f64 (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (exp.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(*.f64 (exp.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (-.f64 #s(literal 0 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 #s(literal 0 binary64) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (log.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)))
(fma.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)))
(neg.f64 (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) (-.f64 (*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))) (*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))))
(/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 #s(literal 2 binary64) (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/4 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(hypot.f64 re im)
(hypot.f64 im re)
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 (hypot.f64 (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re re)))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (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 (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.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 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (*.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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (sqrt.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (sqrt.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))) (sqrt.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (sqrt.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 (*.f64 (*.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 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (neg.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (neg.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (neg.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (pow.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))) (sqrt.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(*.f64 (sqrt.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (sqrt.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)))
(*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 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 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 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 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 re im)))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im 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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (pow.f64 (/.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.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 re (*.f64 re (*.f64 re re)) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (pow.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im))))))
(*.f64 (pow.f64 (pow.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (fma.f64 (*.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 (+.f64 re im) (-.f64 re im)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re)))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im 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 (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re re)))))))
(*.f64 (sqrt.f64 (/.f64 (fma.f64 re (*.f64 (*.f64 re re) (*.f64 re (*.f64 re re))) (*.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 re (*.f64 re (*.f64 re re)) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (sqrt.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im))))))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 re)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 re)) #s(literal 1 binary64)))
(pow.f64 re #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 re))
(*.f64 re re)
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 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)

simplify498.0ms (11.3%)

Memory
33.2MiB live, 911.3MiB allocated
Algorithm
1×egg-herbie
Rules
15 952×accelerator-lowering-fma.f32
15 952×accelerator-lowering-fma.f64
5 372×*-lowering-*.f32
5 372×*-lowering-*.f64
3 012×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01861076
15101054
215321044
353611010
08221932
Stop Event
1×iter limit
1×node limit
Counts
96 → 96
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))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (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))))))))
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))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 re (*.f64 re (fma.f64 re (*.f64 (/.f64 re (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64)) (/.f64 #s(literal -1/4 binary64) (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 im (*.f64 (/.f64 im (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1/4 binary64)) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (fma.f64 (*.f64 im im) (fma.f64 im (*.f64 (/.f64 im (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1/4 binary64)) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 re))
(* -1 (log (/ -1 re)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 im (*.f64 (/.f64 im (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1/4 binary64)) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 im (*.f64 (/.f64 im (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1/4 binary64)) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 im (*.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 im (*.f64 (/.f64 im (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal -1/4 binary64)) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 re (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im)) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (-.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (/.f64 (*.f64 re re) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 im im)) #s(literal 1/2 binary64)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 re (*.f64 re (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 im 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 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1 binary64)) (/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) re))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1 binary64))) (/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) re))
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 #s(literal 0 binary64) (fma.f64 (*.f64 im im) (/.f64 #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)))))))
(-.f64 (*.f64 re (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1/8 binary64) #s(literal -1 binary64))) (/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(-.f64 #s(literal 0 binary64) (fma.f64 re (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re (*.f64 re re)))) #s(literal 1 binary64))) (/.f64 (*.f64 im (*.f64 im #s(literal 1/2 binary64))) re)))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (/.f64 (*.f64 im im) re) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/8 binary64) (*.f64 re re)) #s(literal 1/2 binary64)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 im (*.f64 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 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal 1/8 binary64) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(-.f64 #s(literal 0 binary64) (fma.f64 im (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) 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)

eval80.0ms (1.8%)

Memory
-17.3MiB live, 96.5MiB allocated
Compiler

Compiled 14 583 to 1 284 computations (91.2% saved)

prune44.0ms (1%)

Memory
-9.7MiB live, 112.5MiB allocated
Pruning

5 alts after pruning (5 fresh and 0 done)

PrunedKeptTotal
New3515356
Fresh000
Picked101
Done000
Total3525357
Accuracy
100.0%
Counts
357 → 5
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶53.0%
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
▶99.2%
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
▶100.0%
(log.f64 (hypot.f64 re im))
▶52.3%
(log.f64 (sqrt.f64 (*.f64 im im)))
▶98.5%
(log.f64 im)
Compiler

Compiled 78 to 52 computations (33.3% saved)

simplify6.0ms (0.1%)

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

Found 14 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(/.f64 re im)
✓cost-diff0
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
✓cost-diff0
(fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
✓cost-diff0
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
✓cost-diff0
(*.f64 im im)
✓cost-diff0
(fma.f64 re re (*.f64 im im))
✓cost-diff0
(log.f64 (fma.f64 re re (*.f64 im im)))
✓cost-diff0
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
✓cost-diff0
(*.f64 im im)
✓cost-diff0
(log.f64 (sqrt.f64 (*.f64 im im)))
✓cost-diff832
(sqrt.f64 (*.f64 im im))
✓cost-diff0
(log.f64 im)
✓cost-diff0
(log.f64 (hypot.f64 re im))
✓cost-diff5120
(hypot.f64 re im)
Rules
48×*-lowering-*.f32
48×*-lowering-*.f64
20×accelerator-lowering-fma.f32
20×accelerator-lowering-fma.f64
12×*-commutative
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01892
12892
24192
34892
45192
55292
05277
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(log (sqrt (+ (* re re) (* im im))))
(sqrt (+ (* re re) (* im im)))
re
im
(log im)
im
(log (sqrt (* im im)))
(sqrt (* im im))
(* im im)
im
(* (log (+ (* re re) (* im im))) 1/2)
(log (+ (* re re) (* im im)))
(+ (* re re) (* im im))
re
(* im im)
im
1/2
(log (+ (* re (* 1/2 (/ re im))) im))
(+ (* re (* 1/2 (/ re im))) im)
re
(* 1/2 (/ re im))
1/2
(/ re im)
im
Outputs
(log (sqrt (+ (* re re) (* im im))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(sqrt (+ (* re re) (* im im)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
re
im
(log im)
(log.f64 im)
im
(log (sqrt (* im im)))
(log.f64 (fabs.f64 im))
(sqrt (* im im))
(fabs.f64 im)
(* im im)
(*.f64 im im)
im
(* (log (+ (* re re) (* im im))) 1/2)
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64))
(log (+ (* re re) (* im im)))
(log.f64 (fma.f64 im im (*.f64 re re)))
(+ (* re re) (* im im))
(fma.f64 im im (*.f64 re re))
re
(* im im)
(*.f64 im im)
im
1/2
#s(literal 1/2 binary64)
(log (+ (* re (* 1/2 (/ re im))) im))
(log.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im))
(+ (* re (* 1/2 (/ re im))) im)
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
re
(* 1/2 (/ re im))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
1/2
#s(literal 1/2 binary64)
(/ re im)
(/.f64 re im)
im

localize67.0ms (1.5%)

Memory
27.8MiB live, 141.3MiB allocated
Localize:

Found 14 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
✓accuracy100.0%
(/.f64 re im)
✓accuracy100.0%
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
✓accuracy100.0%
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
✓accuracy100.0%
(fma.f64 re re (*.f64 im im))
✓accuracy100.0%
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
✓accuracy100.0%
(*.f64 im im)
✓accuracy53.0%
(log.f64 (fma.f64 re re (*.f64 im im)))
✓accuracy100.0%
(*.f64 im im)
✓accuracy100.0%
(log.f64 (sqrt.f64 (*.f64 im im)))
✓accuracy54.6%
(sqrt.f64 (*.f64 im im))
✓accuracy100.0%
(log.f64 im)
✓accuracy100.0%
(hypot.f64 re im)
✓accuracy100.0%
(log.f64 (hypot.f64 re im))
Samples
46.0ms256×0valid
Compiler

Compiled 83 to 20 computations (75.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 32.0ms
ival-log: 13.0ms (40.4% of total)
ival-mult: 7.0ms (21.8% of total)
ival-hypot: 6.0ms (18.7% of total)
ival-div: 2.0ms (6.2% of total)
ival-add: 2.0ms (6.2% of total)
ival-sqrt: 2.0ms (6.2% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

series77.0ms (1.7%)

Memory
6.9MiB live, 166.3MiB allocated
Counts
13 → 264
Calls
Call 1
Inputs
#<alt (sqrt (+ (* re re) (* im im)))>
#<alt (log (sqrt (+ (* re re) (* im im))))>
#<alt (log im)>
#<alt (sqrt (* im im))>
#<alt (log (sqrt (* im im)))>
#<alt (* im im)>
#<alt (* (log (+ (* re re) (* im im))) 1/2)>
#<alt (log (+ (* re re) (* im im)))>
#<alt (+ (* re re) (* im im))>
#<alt (log (+ (* re (* 1/2 (/ re im))) im))>
#<alt (+ (* re (* 1/2 (/ re im))) im)>
#<alt (* 1/2 (/ re im))>
#<alt (/ re im)>
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 (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (log re)>
#<alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt im>
#<alt (* -1 im)>
#<alt (* -1 im)>
#<alt (* -1 im)>
#<alt (* -1 im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (* 1/2 (log (pow im 2)))>
#<alt (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* 1/2 (log (pow re 2)))>
#<alt (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (log (pow im 2))>
#<alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))>
#<alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))>
#<alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))>
#<alt (* -2 (log (/ 1 re)))>
#<alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))>
#<alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))>
#<alt (* -2 (log (/ -1 re)))>
#<alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))>
#<alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))>
#<alt (log (pow re 2))>
#<alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))>
#<alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))>
#<alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))>
#<alt (* -2 (log (/ 1 im)))>
#<alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))>
#<alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))>
#<alt (* -2 (log (/ -1 im)))>
#<alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))>
#<alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (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 (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))>
#<alt (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))>
#<alt (+ (log (* 1/2 (pow re 2))) (* -1 (log im)))>
#<alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))>
#<alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (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 (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
#<alt (/ re im)>
Calls

66 calls:

TimeVariablePointExpression
32.0ms
im
@0
(log im)
18.0ms
im
@-inf
(log im)
9.0ms
im
@inf
(log im)
2.0ms
re
@0
(log (+ (* re re) (* im im)))
1.0ms
re
@0
(* (log (+ (* re re) (* im im))) 1/2)

rewrite409.0ms (9.2%)

Memory
-5.0MiB live, 729.4MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 422×accelerator-lowering-fma.f32
5 422×accelerator-lowering-fma.f64
4 214×*-lowering-*.f32
4 214×*-lowering-*.f64
1 926×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01877
16776
244876
3491276
0812957
Stop Event
1×iter limit
1×node limit
Counts
13 → 568
Calls
Call 1
Inputs
(sqrt (+ (* re re) (* im im)))
(log (sqrt (+ (* re re) (* im im))))
(log im)
(sqrt (* im im))
(log (sqrt (* im im)))
(* im im)
(* (log (+ (* re re) (* im im))) 1/2)
(log (+ (* re re) (* im im)))
(+ (* re re) (* im im))
(log (+ (* re (* 1/2 (/ re im))) im))
(+ (* re (* 1/2 (/ re im))) im)
(* 1/2 (/ re im))
(/ re im)
Outputs
(exp.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal 1/2 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(hypot.f64 re im)
(hypot.f64 re (-.f64 #s(literal 0 binary64) im))
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 (-.f64 #s(literal 0 binary64) im) re)
(hypot.f64 (-.f64 #s(literal 0 binary64) im) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 re)) (-.f64 #s(literal 0 binary64) im))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 #s(literal 1 binary64) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 #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 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 (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 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(*.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.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))))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 (/.f64 #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 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))))
(-.f64 #s(literal 0 binary64) (log.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)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (log.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))) (log.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 (log.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (log.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))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (/.f64 #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))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(neg.f64 (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))))
(neg.f64 (log.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)))))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 (exp.f64 #s(literal 1/2 binary64))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (exp.f64 (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 #s(literal 1/4 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))))
(log.f64 im)
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (log.f64 (/.f64 (sqrt.f64 im) #s(literal 1 binary64))))
(+.f64 (log.f64 im) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 im))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (-.f64 #s(literal 0 binary64) im)))
(-.f64 (log.f64 im) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) im)) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal 1/2 binary64) (log.f64 im) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(fma.f64 #s(literal 1/2 binary64) (log.f64 im) (log.f64 (/.f64 (sqrt.f64 im) #s(literal 1 binary64))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 0 binary64))
(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(fma.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (log.f64 (/.f64 (sqrt.f64 im) #s(literal 1 binary64))))
(fma.f64 #s(literal 1 binary64) (log.f64 im) #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1/2 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1/4 binary64) (*.f64 #s(literal 2 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(fma.f64 #s(literal 1/4 binary64) (*.f64 #s(literal 2 binary64) (log.f64 im)) (log.f64 (/.f64 (sqrt.f64 im) #s(literal 1 binary64))))
(fma.f64 #s(literal 1/4 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 0 binary64))
(neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)))
(/.f64 (+.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64))) (log.f64 (/.f64 (sqrt.f64 im) (sqrt.f64 im))))
(*.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (log.f64 im)))
(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/4 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im)))
im
(exp.f64 (log.f64 im))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 1 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 1/2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 4 binary64)) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 2 binary64)) #s(literal 1/4 binary64)))
(fabs.f64 im)
(fabs.f64 (-.f64 #s(literal 0 binary64) im))
(fabs.f64 (-.f64 im #s(literal 0 binary64)))
(-.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) im))
(sqrt.f64 (*.f64 im im))
(neg.f64 (-.f64 #s(literal 0 binary64) im))
(/.f64 im #s(literal 1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) im) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) im))
(pow.f64 im #s(literal 1 binary64))
(pow.f64 (*.f64 im im) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im (*.f64 im (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) im) #s(literal -1 binary64))
(*.f64 im #s(literal 1 binary64))
(*.f64 (sqrt.f64 im) (sqrt.f64 im))
(*.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) im)
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) im))
(log.f64 im)
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (log.f64 (/.f64 (sqrt.f64 im) #s(literal 1 binary64))))
(+.f64 (log.f64 im) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 im))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (-.f64 #s(literal 0 binary64) im)))
(-.f64 (log.f64 im) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (log.f64 im)))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) im)) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal 1/2 binary64) (log.f64 im) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(fma.f64 #s(literal 1/2 binary64) (log.f64 im) (log.f64 (/.f64 (sqrt.f64 im) #s(literal 1 binary64))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 0 binary64))
(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(fma.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 im)) (log.f64 (/.f64 (sqrt.f64 im) #s(literal 1 binary64))))
(fma.f64 #s(literal 1 binary64) (log.f64 im) #s(literal 0 binary64))
(fma.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1/2 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1/4 binary64) (*.f64 #s(literal 2 binary64) (log.f64 im)) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(fma.f64 #s(literal 1/4 binary64) (*.f64 #s(literal 2 binary64) (log.f64 im)) (log.f64 (/.f64 (sqrt.f64 im) #s(literal 1 binary64))))
(fma.f64 #s(literal 1/4 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 0 binary64))
(neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 im)))
(/.f64 (+.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64))) (log.f64 (/.f64 (sqrt.f64 im) (sqrt.f64 im))))
(*.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (log.f64 im)))
(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 im)))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/4 binary64) (*.f64 #s(literal 4 binary64) (log.f64 im)))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)))
(exp.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 4 binary64)))
(exp.f64 (*.f64 (*.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 im)) #s(literal 2 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 1 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1/4 binary64)) #s(literal 4 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 1/2 binary64)) #s(literal 4 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 4 binary64)) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(fabs.f64 (*.f64 im im))
(fabs.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)))
(sqrt.f64 (*.f64 im (*.f64 im (*.f64 im im))))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 im) #s(literal 4 binary64))
(pow.f64 (-.f64 #s(literal 0 binary64) im) #s(literal 2 binary64))
(pow.f64 (*.f64 im (*.f64 im (*.f64 im im))) #s(literal 1/2 binary64))
(pow.f64 (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) #s(literal 1/4 binary64))
(*.f64 im im)
(*.f64 (sqrt.f64 im) (*.f64 im (sqrt.f64 im)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) im))
(*.f64 (*.f64 im (sqrt.f64 im)) (sqrt.f64 im))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.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))))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 (/.f64 #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 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))))
(-.f64 #s(literal 0 binary64) (log.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)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (sqrt.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (log.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))) (log.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 (log.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (log.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))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (/.f64 #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))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im))) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(neg.f64 (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))))
(neg.f64 (log.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)))))))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 (exp.f64 #s(literal 1/2 binary64))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (exp.f64 (log.f64 (fma.f64 re re (*.f64 im im))))))
(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(*.f64 #s(literal 1/4 binary64) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re re (*.f64 im im)))))
(log.f64 (fma.f64 re re (*.f64 im im)))
(+.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(+.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(+.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(+.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(+.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (-.f64 #s(literal 0 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(+.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(+.f64 (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))
(+.f64 (-.f64 #s(literal 0 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(+.f64 (log.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))))) (log.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (log.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im))) (log.f64 (+.f64 re im)))
(+.f64 (log.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))) (log.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 (log.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(+.f64 (log.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)))))) (log.f64 (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re))))))
(-.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.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))))) (log.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (log.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))) (log.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 re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))))
(-.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 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)))))) (log.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 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 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)))))) (log.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(-.f64 (log.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)))))) (log.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) #s(literal 1 binary64))) (log.f64 (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (log.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 (log.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (log.f64 (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.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))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))) (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.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)))) (log.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 (log.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)))))) (log.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 (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 1 binary64))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1 binary64))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (log.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))) (log.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 (log.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(-.f64 (log.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))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(-.f64 (log.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (log.f64 (-.f64 re im)))
(fma.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))))
(fma.f64 #s(literal -1 binary64) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(neg.f64 (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(neg.f64 (log.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 2 binary64)) (*.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 2 binary64))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 2 binary64))) (log.f64 (*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(+.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 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (*.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 (sqrt.f64 im) (*.f64 im (sqrt.f64 im)) (*.f64 re re))
(fma.f64 (-.f64 #s(literal 0 binary64) im) (-.f64 #s(literal 0 binary64) 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 im (sqrt.f64 im)) (sqrt.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 (*.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 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))))
(/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))) (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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (-.f64 (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 (*.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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) #s(literal 1 binary64)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (*.f64 (*.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 (fma.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (-.f64 re im))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1 binary64))
(*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (*.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 (fma.f64 re re (*.f64 im im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(*.f64 #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 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(*.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(*.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) (+.f64 re im))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re re (*.f64 im im)))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (fma.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 re (*.f64 re (*.f64 re (*.f64 re (*.f64 re re)))))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (*.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 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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))))) (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 re re (*.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im im) (fma.f64 re re (*.f64 im im)) (*.f64 re (*.f64 re (*.f64 re re)))))
(log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))
(+.f64 (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)) (log.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))))
(+.f64 (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)) (log.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))
(+.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(+.f64 (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))) (log.f64 (*.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))))
(+.f64 (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))) (log.f64 (/.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(+.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (-.f64 #s(literal 0 binary64) (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))
(+.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
(+.f64 (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))))
(+.f64 (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im))))
(+.f64 (log.f64 (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))))
(+.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))) (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))))
(+.f64 (-.f64 #s(literal 0 binary64) (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (log.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))))
(+.f64 (log.f64 (/.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))))) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
(+.f64 (log.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))) (*.f64 im (*.f64 (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)) (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))))) (log.f64 (fma.f64 (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))) (-.f64 (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))))) (*.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))))
(+.f64 (log.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)) (-.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))))))) (log.f64 (-.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))))))
(+.f64 (log.f64 (/.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))))) (log.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))))
(-.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))
(-.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))
(-.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)) (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))))))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))) (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))))) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))
(-.f64 (log.f64 (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))))) (log.f64 (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))))
(-.f64 (log.f64 (*.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))))) (log.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)))))
(-.f64 (log.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) #s(literal 9 binary64)))) (log.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)) (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))))))
(-.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))))) (log.f64 (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))))))
(-.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))))) (log.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (*.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))))
(-.f64 (log.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))) (log.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))
(-.f64 (log.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) #s(literal 9 binary64))) #s(literal 1 binary64))) (log.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (log.f64 (*.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64))) (log.f64 (*.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (*.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) #s(literal 1 binary64))) (log.f64 (*.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))
(-.f64 (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))))) (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))))
(-.f64 (log.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))))) (log.f64 (neg.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im))))
(-.f64 (log.f64 (neg.f64 (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))))))) (log.f64 (neg.f64 (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))))
(-.f64 (log.f64 (-.f64 (pow.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) #s(literal 3 binary64)))) (log.f64 (fma.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (fma.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))))))
(-.f64 (log.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))) (*.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))) (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (/.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))))
(-.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64))) (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))
(-.f64 (log.f64 (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) #s(literal 1 binary64))) (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))
(-.f64 (log.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))) (log.f64 (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))) (log.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))) (log.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (*.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))) (log.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))))
(fma.f64 #s(literal -1 binary64) (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))) (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))))
(fma.f64 #s(literal -1 binary64) (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (log.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))) (log.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))) (log.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))
(neg.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))))
(neg.f64 (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 1 binary64))))
(neg.f64 (log.f64 (/.f64 (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)) (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))) #s(literal 2 binary64))) (log.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) #s(literal 2 binary64))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))))
(+.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))
(+.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)
(+.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(exp.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))) #s(literal -1 binary64)))
(-.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))
(-.f64 (/.f64 (*.f64 im im) (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))) (/.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (-.f64 im (/.f64 (*.f64 (*.f64 re 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 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 (*.f64 re re) (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 im #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.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/2 binary64) (/.f64 #s(literal 1 binary64) re)) 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 (*.f64 re (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 (sqrt.f64 im) (sqrt.f64 im) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))
(fma.f64 (sqrt.f64 im) (/.f64 (sqrt.f64 im) #s(literal 1 binary64)) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))
(fma.f64 (-.f64 #s(literal 0 binary64) re) (*.f64 (/.f64 #s(literal -1 binary64) im) (*.f64 re #s(literal 1/2 binary64))) im)
(fma.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 #s(literal 1 binary64) im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)
(fma.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)
(fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im)
(fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 (/.f64 (*.f64 re (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) im) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))
(fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (/.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 (*.f64 re re) #s(literal 1/2 binary64))) im) (/.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 (*.f64 (/.f64 re im) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (/.f64 (/.f64 re im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 re (/.f64 #s(literal 1 binary64) re)) im)
(fma.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 re (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) 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 re) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (/.f64 re (sqrt.f64 im)) (/.f64 (*.f64 re #s(literal 1/2 binary64)) (sqrt.f64 im)) im)
(fma.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (sqrt.f64 im)) (/.f64 re (sqrt.f64 im)) im)
(fma.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal -1 binary64)) (/.f64 re (-.f64 #s(literal 0 binary64) im)) im)
(fma.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) im)) (-.f64 #s(literal 0 binary64) re) im)
(fma.f64 (/.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))) (neg.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re 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)
(neg.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))
(/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)) (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))))))
(/.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))
(/.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im))
(/.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) #s(literal 9 binary64))) (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)) (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))))
(/.f64 (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))))) (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.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 re re) #s(literal 1/2 binary64)) im) im) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (*.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))))
(/.f64 (*.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im))))
(/.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))) (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))
(/.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) 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 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (*.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))) (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))))) (neg.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))
(/.f64 (neg.f64 (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))))) (neg.f64 (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))))
(/.f64 (-.f64 (pow.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) #s(literal 3 binary64)) (pow.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (fma.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (/.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))) (*.f64 (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))) (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))))) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (/.f64 (*.f64 re re) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)) (*.f64 im (/.f64 im (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) #s(literal 1 binary64)) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) #s(literal 1 binary64)) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))
(/.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im))))) (pow.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))) (fma.f64 (*.f64 im (*.f64 im im)) (-.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im))) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (*.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))))
(/.f64 (*.f64 (*.f64 (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im))) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im im)))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)) (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))))) #s(literal -1 binary64))
(*.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im))))
(*.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im)))
(*.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))
(*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)) (*.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)) (/.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))))
(*.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))
(*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)))))
(*.f64 (-.f64 #s(literal 0 binary64) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im))) (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))
(*.f64 (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))))
(*.f64 (-.f64 (*.f64 im im) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im)))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (fma.f64 (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))) (*.f64 im (*.f64 (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)) (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))))) (fma.f64 (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))) (-.f64 (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im))) (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))))) (*.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))))))
(*.f64 (/.f64 (fma.f64 im (*.f64 im im) (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))))) (*.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) (-.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im) (*.f64 im im)) (-.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))))) (-.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)))) (*.f64 im (-.f64 im (/.f64 (*.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))))
(*.f64 (/.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (*.f64 im im))) (-.f64 (*.f64 (*.f64 re (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im)))) (*.f64 im (*.f64 im im)))) (fma.f64 (*.f64 re re) (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (*.f64 im (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))))
(exp.f64 (*.f64 (log.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(neg.f64 (*.f64 (/.f64 re (-.f64 #s(literal 0 binary64) im)) #s(literal 1/2 binary64)))
(neg.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 re (-.f64 #s(literal 0 binary64) im))))
(neg.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) im)))
(neg.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(/.f64 #s(literal 1/2 binary64) (/.f64 im re))
(/.f64 #s(literal 1 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64)))))
(/.f64 (*.f64 re #s(literal -1/2 binary64)) (-.f64 #s(literal 0 binary64) im))
(/.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1 binary64) re))
(/.f64 #s(literal -1/2 binary64) (/.f64 im (-.f64 #s(literal 0 binary64) re)))
(/.f64 (neg.f64 (*.f64 re #s(literal -1/2 binary64))) im)
(/.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (sqrt.f64 im)) (sqrt.f64 im))
(/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) 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))
(pow.f64 (/.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(*.f64 (-.f64 #s(literal 0 binary64) re) (*.f64 (/.f64 #s(literal -1 binary64) im) #s(literal 1/2 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) re) (/.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 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 re #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im))
(*.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) re)
(*.f64 #s(literal -1/2 binary64) (/.f64 re (-.f64 #s(literal 0 binary64) im)))
(*.f64 (/.f64 re (sqrt.f64 im)) (/.f64 #s(literal 1/2 binary64) (sqrt.f64 im)))
(*.f64 (/.f64 #s(literal 1/2 binary64) (sqrt.f64 im)) (/.f64 re (sqrt.f64 im)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) re) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (-.f64 #s(literal 0 binary64) im)) (-.f64 #s(literal 0 binary64) re))
(exp.f64 (*.f64 (log.f64 (/.f64 im re)) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 re (-.f64 #s(literal 0 binary64) im)))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) im)) (/.f64 re (-.f64 #s(literal 0 binary64) im)))
(neg.f64 (/.f64 re (-.f64 #s(literal 0 binary64) im)))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 re (-.f64 #s(literal 0 binary64) im))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 im re)))
(/.f64 re im)
(/.f64 (-.f64 #s(literal 0 binary64) re) (-.f64 #s(literal 0 binary64) im))
(/.f64 #s(literal 1 binary64) (/.f64 im re))
(/.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 #s(literal 1 binary64) re))
(/.f64 #s(literal -1 binary64) (/.f64 im (-.f64 #s(literal 0 binary64) re)))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) re) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) im))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)) (-.f64 #s(literal 0 binary64) im))
(/.f64 (/.f64 re (sqrt.f64 im)) (sqrt.f64 im))
(/.f64 (/.f64 (-.f64 #s(literal 0 binary64) re) #s(literal -1 binary64)) im)
(pow.f64 (/.f64 re im) #s(literal 1 binary64))
(pow.f64 (/.f64 im re) #s(literal -1 binary64))
(pow.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (/.f64 re im) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(*.f64 re (/.f64 #s(literal 1 binary64) im))
(*.f64 (/.f64 re im) #s(literal 1 binary64))
(*.f64 (-.f64 #s(literal 0 binary64) re) (/.f64 #s(literal -1 binary64) im))
(*.f64 #s(literal 1 binary64) (/.f64 re im))
(*.f64 (/.f64 #s(literal 1 binary64) im) re)
(*.f64 #s(literal -1 binary64) (/.f64 re (-.f64 #s(literal 0 binary64) im)))
(*.f64 (/.f64 #s(literal -1 binary64) im) (-.f64 #s(literal 0 binary64) re))
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) re)) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 re (sqrt.f64 im)) (/.f64 #s(literal 1 binary64) (sqrt.f64 im)))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal 1/2 binary64)))

simplify498.0ms (11.2%)

Memory
9.2MiB live, 918.3MiB allocated
Algorithm
1×egg-herbie
Rules
15 298×accelerator-lowering-fma.f32
15 298×accelerator-lowering-fma.f64
4 906×+-lowering-+.f64
4 906×+-lowering-+.f32
3 894×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03373007
19562943
228032919
369092898
084892697
Stop Event
1×iter limit
1×node limit
Counts
264 → 264
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))))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
im
im
im
im
im
im
im
im
(* -1 im)
(* -1 im)
(* -1 im)
(* -1 im)
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ -1 im)))
(* -1 (log (/ -1 im)))
(* -1 (log (/ -1 im)))
(* -1 (log (/ -1 im)))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(* 1/2 (log (pow im 2)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* 1/2 (log (pow re 2)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (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))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (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))
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal 1 binary64)) (*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal 1 binary64))) (*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re))))
(* -1 re)
(-.f64 #s(literal 0 binary64) re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(-.f64 #s(literal 0 binary64) (fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal 1 binary64)) (*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re)))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(-.f64 #s(literal 0 binary64) (fma.f64 re (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal 1 binary64))) (*.f64 #s(literal 1 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im 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 im) (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im im) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) re)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1 binary64) (*.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))))))
(*.f64 im (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) #s(literal 1 binary64)))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(*.f64 im (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) #s(literal 1 binary64))))
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 #s(literal 0 binary64) (fma.f64 #s(literal 1 binary64) (*.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)))))))
(*.f64 (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(-.f64 #s(literal 0 binary64) (*.f64 im (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) #s(literal 1 binary64)))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 im (/.f64 im (*.f64 re re))) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 im (*.f64 im (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (log.f64 re)))
(* -1 (log (/ -1 re)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 im (/.f64 im (*.f64 re re))) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 im (/.f64 im (*.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (fma.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (/.f64 #s(literal 1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (/.f64 (*.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
im
im
im
im
im
im
im
im
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(* -1 im)
(-.f64 #s(literal 0 binary64) im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(pow im 2)
(*.f64 im im)
(* 1/2 (log (pow im 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(*.f64 #s(literal 1/2 binary64) (fma.f64 re (/.f64 re (*.f64 im im)) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 im (/.f64 im (*.f64 re re))) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 re)))
(* -1 (log (/ -1 re)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 im (/.f64 im (*.f64 re re))) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(* 1/2 (log (pow re 2)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(*.f64 #s(literal 1/2 binary64) (fma.f64 im (/.f64 im (*.f64 re re)) (log.f64 (*.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 im (*.f64 im (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 re re)) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 re re) (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 0 binary64)))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 0 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/4 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(fma.f64 re (/.f64 re (*.f64 im im)) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (log.f64 (*.f64 im im)))
(* -2 (log (/ 1 re)))
(*.f64 #s(literal 2 binary64) (log.f64 re))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 im (/.f64 im (*.f64 re re)) (*.f64 #s(literal 2 binary64) (log.f64 re)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 2 binary64) (log.f64 re) (*.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re)))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 re) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/3 binary64)) (pow.f64 re #s(literal 6 binary64)))))
(* -2 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (*.f64 im (/.f64 im (*.f64 re re))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/3 binary64)) (pow.f64 re #s(literal 6 binary64)))))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(fma.f64 im (/.f64 im (*.f64 re re)) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 im im) (fma.f64 im (*.f64 im (fma.f64 (*.f64 im im) (/.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (log.f64 (*.f64 re re)))
(* -2 (log (/ 1 im)))
(*.f64 #s(literal 2 binary64) (log.f64 im))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 re (/.f64 re (*.f64 im im)) (*.f64 #s(literal 2 binary64) (log.f64 im)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (*.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 im im)))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (fma.f64 #s(literal 2 binary64) (log.f64 im) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/3 binary64)) (pow.f64 im #s(literal 6 binary64)))))
(* -2 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re #s(literal -1/2 binary64)) (/.f64 re (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/3 binary64)) (pow.f64 im #s(literal 6 binary64)))))
(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))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/24 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (*.f64 im (/.f64 im (*.f64 re re))) (fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal 2 binary64) (log.f64 re) (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 2 binary64) (*.f64 re re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(fma.f64 im (*.f64 im (fma.f64 (*.f64 im im) (/.f64 #s(literal -2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 2 binary64) (*.f64 re re)))) (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 8/3 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (/.f64 (*.f64 im #s(literal 2 binary64)) (*.f64 re re)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 im (*.f64 im (fma.f64 (*.f64 im im) (/.f64 #s(literal -2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 2 binary64) (*.f64 re re)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(fma.f64 im (*.f64 im (fma.f64 (*.f64 im im) (/.f64 #s(literal -2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 2 binary64) (*.f64 re re)))) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 8/3 binary64) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(-.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 im))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 #s(literal 2 binary64) (*.f64 im (/.f64 im (*.f64 re re))) (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (log.f64 im))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (/.f64 #s(literal -2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))) (/.f64 #s(literal 2 binary64) (*.f64 re re))) (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (log.f64 im))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(fma.f64 (*.f64 im im) (fma.f64 im (*.f64 im (fma.f64 (*.f64 im im) (/.f64 #s(literal 8/3 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -2 binary64) (*.f64 (*.f64 re re) (*.f64 re re))))) (/.f64 #s(literal 2 binary64) (*.f64 re re))) (-.f64 (log.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 im)))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) (*.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/24 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/24 binary64) (pow.f64 im #s(literal 6 binary64))) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) 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 #s(literal 1/2 binary64) (/.f64 (*.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 #s(literal 1/2 binary64) (/.f64 (*.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 #s(literal 1/2 binary64) (/.f64 (*.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 binary64) (*.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 binary64) (*.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 binary64) (*.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im)) im)
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) #s(literal -1 binary64)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) #s(literal -1 binary64)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) im) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) #s(literal -1 binary64)))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(* 1/2 (/ re im))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)
(/ re im)
(/.f64 re im)

eval392.0ms (8.9%)

Memory
-95.0MiB live, 204.0MiB allocated
Compiler

Compiled 22 379 to 2 018 computations (91% saved)

prune89.0ms (2%)

Memory
29.0MiB live, 223.3MiB allocated
Pruning

5 alts after pruning (1 fresh and 4 done)

PrunedKeptTotal
New8661867
Fresh000
Picked145
Done000
Total8675872
Accuracy
100.0%
Counts
872 → 5
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓53.0%
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
▶52.3%
(*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64))
✓99.2%
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
✓100.0%
(log.f64 (hypot.f64 re im))
✓98.5%
(log.f64 im)
Compiler

Compiled 40 to 27 computations (32.5% saved)

simplify3.0ms (0.1%)

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

Found 3 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(*.f64 im im)
✓cost-diff0
(log.f64 (*.f64 im im))
✓cost-diff0
(*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64))
Rules
6×*-lowering-*.f32
6×*-lowering-*.f64
2×*-commutative
2×log-lowering-log.f64
2×log-lowering-log.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0515
1615
0615
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(* (log (* im im)) 1/2)
(log (* im im))
(* im im)
im
1/2
Outputs
(* (log (* im im)) 1/2)
(*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64))
(log (* im im))
(log.f64 (*.f64 im im))
(* im im)
(*.f64 im im)
im
1/2
#s(literal 1/2 binary64)

localize104.0ms (2.3%)

Memory
-2.1MiB live, 38.3MiB allocated
Localize:

Found 3 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64))
✓accuracy100.0%
(*.f64 im im)
✓accuracy53.0%
(log.f64 (*.f64 im im))
Samples
97.0ms256×0valid
Compiler

Compiled 17 to 8 computations (52.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 7.0ms
ival-log: 3.0ms (44.3% of total)
ival-mult: 3.0ms (44.3% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series21.0ms (0.5%)

Memory
-11.1MiB live, 59.4MiB allocated
Counts
3 → 36
Calls
Call 1
Inputs
#<alt (* (log (* im im)) 1/2)>
#<alt (log (* im im))>
#<alt (* im im)>
Outputs
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (* 2 (log im))>
#<alt (* 2 (log im))>
#<alt (* 2 (log im))>
#<alt (* 2 (log im))>
#<alt (* -2 (log (/ 1 im)))>
#<alt (* -2 (log (/ 1 im)))>
#<alt (* -2 (log (/ 1 im)))>
#<alt (* -2 (log (/ 1 im)))>
#<alt (* -2 (log (/ -1 im)))>
#<alt (* -2 (log (/ -1 im)))>
#<alt (* -2 (log (/ -1 im)))>
#<alt (* -2 (log (/ -1 im)))>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
#<alt (pow im 2)>
Calls

9 calls:

TimeVariablePointExpression
11.0ms
im
@inf
(* (log (* im im)) 1/2)
9.0ms
im
@0
(* (log (* im im)) 1/2)
0.0ms
im
@-inf
(* (log (* im im)) 1/2)
0.0ms
im
@0
(log (* im im))
0.0ms
im
@inf
(log (* im im))

rewrite46.0ms (1%)

Memory
8.0MiB live, 78.6MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
46×*-lowering-*.f32
46×*-lowering-*.f64
36×accelerator-lowering-fma.f32
36×accelerator-lowering-fma.f64
32×/-lowering-/.f32
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
0515
11015
2305
01625
Stop Event
1×iter limit
1×iter limit
1×iter limit
1×unsound
Counts
3 → 58
Calls
Call 1
Inputs
(* (log (* im im)) 1/2)
(log (* im im))
(* im im)
Outputs
(log.f64 im)
(+.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(-.f64 (/.f64 (*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 (*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 1/2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 #s(literal 2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(/.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (neg.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) #s(literal 1/2 binary64)) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 1/2 binary64))
(*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 2 binary64))
(*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))))
(*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) #s(literal 0 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(log.f64 im)
(+.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(-.f64 (/.f64 (*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) #s(literal 0 binary64)) (/.f64 (*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) #s(literal 0 binary64)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 1/2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 #s(literal 2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(/.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (neg.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))))
(/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)))
(/.f64 (*.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) #s(literal 1/2 binary64)) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)))
(*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 1/2 binary64))
(*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 2 binary64))
(*.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 2 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(*.f64 (*.f64 (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)) #s(literal 0 binary64))))
(*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) #s(literal 0 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
im
(exp.f64 (/.f64 #s(literal 0 binary64) #s(literal 0 binary64)))
(pow.f64 im #s(literal 2 binary64))
(pow.f64 im #s(literal 1 binary64))
(*.f64 im im)
(*.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)))

simplify10.0ms (0.2%)

Memory
23.5MiB live, 23.5MiB allocated
Algorithm
1×egg-herbie
Rules
58×*-lowering-*.f32
58×*-lowering-*.f64
56×accelerator-lowering-fma.f32
56×accelerator-lowering-fma.f64
28×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
016128
127128
237128
369128
499128
5107128
6114128
7117128
8118128
0118128
Stop Event
1×iter limit
1×saturated
Counts
36 → 36
Calls
Call 1
Inputs
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ -1 im)))
(* -1 (log (/ -1 im)))
(* -1 (log (/ -1 im)))
(* -1 (log (/ -1 im)))
(* 2 (log im))
(* 2 (log im))
(* 2 (log im))
(* 2 (log im))
(* -2 (log (/ 1 im)))
(* -2 (log (/ 1 im)))
(* -2 (log (/ 1 im)))
(* -2 (log (/ 1 im)))
(* -2 (log (/ -1 im)))
(* -2 (log (/ -1 im)))
(* -2 (log (/ -1 im)))
(* -2 (log (/ -1 im)))
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
(pow im 2)
Outputs
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 (log (/ -1 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* 2 (log im))
(fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 (log im))
(fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 (log im))
(fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64))
(* 2 (log im))
(fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64))
(* -2 (log (/ 1 im)))
(fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64))
(* -2 (log (/ 1 im)))
(fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64))
(* -2 (log (/ 1 im)))
(fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64))
(* -2 (log (/ 1 im)))
(fma.f64 (log.f64 im) #s(literal 2 binary64) #s(literal 0 binary64))
(* -2 (log (/ -1 im)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) #s(literal 0 binary64))
(* -2 (log (/ -1 im)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) #s(literal 0 binary64))
(* -2 (log (/ -1 im)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) #s(literal 0 binary64))
(* -2 (log (/ -1 im)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) #s(literal 0 binary64))
(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)

eval7.0ms (0.2%)

Memory
-16.6MiB live, 22.4MiB allocated
Compiler

Compiled 875 to 93 computations (89.4% saved)

prune10.0ms (0.2%)

Memory
0.5MiB live, 39.6MiB allocated
Pruning

6 alts after pruning (1 fresh and 5 done)

PrunedKeptTotal
New93194
Fresh000
Picked011
Done044
Total93699
Accuracy
100.0%
Counts
99 → 6
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶0.0%
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
✓53.0%
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
✓52.3%
(*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64))
✓99.2%
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
✓100.0%
(log.f64 (hypot.f64 re im))
✓98.5%
(log.f64 im)
Compiler

Compiled 45 to 31 computations (31.1% saved)

simplify4.0ms (0.1%)

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

Found 1 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
Rules
2×/-lowering-/.f32
2×/-lowering-/.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
024
Stop Event
1×iter limit
1×iter limit
1×unsound
Calls
Call 1
Inputs
(/ 0 0)
0
Outputs
(/ 0 0)
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
0
#s(literal 0 binary64)

localize12.0ms (0.3%)

Memory
-7.2MiB live, 31.7MiB allocated
Localize:

Found 1 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
Samples
6.0ms256×0invalid
Compiler

Compiled 6 to 6 computations (0% saved)

Precisions
Click to see histograms. Total time spent on operations: 1.0ms
ival-div: 1.0ms (90.2% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series0.0ms (0%)

Memory
0.1MiB live, 0.1MiB allocated
Counts
1 → 0
Calls
Call 1
Inputs
#<alt (/ 0 0)>
Outputs

rewrite31.0ms (0.7%)

Memory
-35.5MiB live, 24.6MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
2×/-lowering-/.f32
2×/-lowering-/.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
023
Stop Event
1×iter limit
1×iter limit
1×unsound
Counts
1 → 1
Calls
Call 1
Inputs
(/ 0 0)
Outputs
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))

simplify3.0ms (0.1%)

Memory
6.2MiB live, 6.2MiB allocated
Algorithm
1×egg-herbie
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
000
000
Stop Event
1×saturated
1×saturated
Counts
0 → 0
Calls
Call 1
Inputs
Outputs

eval0.0ms (0%)

Memory
1.1MiB live, 1.1MiB allocated
Compiler

Compiled 5 to 4 computations (20% saved)

prune3.0ms (0.1%)

Memory
10.0MiB live, 10.0MiB allocated
Pruning

6 alts after pruning (0 fresh and 6 done)

PrunedKeptTotal
New101
Fresh000
Picked011
Done055
Total167
Accuracy
100.0%
Counts
7 → 6
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓0.0%
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
✓53.0%
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
✓52.3%
(*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64))
✓99.2%
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
✓100.0%
(log.f64 (hypot.f64 re im))
✓98.5%
(log.f64 im)
Compiler

Compiled 94 to 55 computations (41.5% saved)

regimes25.0ms (0.6%)

Memory
-18.0MiB live, 58.3MiB allocated
Counts
8 → 1
Calls
Call 1
Inputs
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
(log.f64 im)
(*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64))
(log.f64 (sqrt.f64 (*.f64 im im)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(log.f64 (hypot.f64 re im))
Outputs
(log.f64 (hypot.f64 re im))
Calls

7 calls:

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

Compiled 46 to 28 computations (39.1% saved)

regimes21.0ms (0.5%)

Memory
14.6MiB live, 52.8MiB allocated
Counts
7 → 1
Calls
Call 1
Inputs
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
(log.f64 im)
(*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64))
(log.f64 (sqrt.f64 (*.f64 im im)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
Outputs
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
Calls

7 calls:

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

Compiled 46 to 28 computations (39.1% saved)

regimes21.0ms (0.5%)

Memory
5.4MiB live, 45.4MiB allocated
Counts
5 → 1
Calls
Call 1
Inputs
(/.f64 #s(literal 0 binary64) #s(literal 0 binary64))
(log.f64 im)
(*.f64 (log.f64 (*.f64 im im)) #s(literal 1/2 binary64))
(log.f64 (sqrt.f64 (*.f64 im im)))
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
Outputs
(log.f64 im)
Calls

7 calls:

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

Compiled 46 to 28 computations (39.1% saved)

regimes10.0ms (0.2%)

Memory
-10.6MiB live, 27.8MiB allocated
Accuracy

Total 0.0b remaining (0%)

Threshold costs 0b (0%)

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

7 calls:

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

Compiled 46 to 28 computations (39.1% saved)

simplify7.0ms (0.2%)

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

Useful iterations: 0 (0.0ms)

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

soundness533.0ms (12%)

Memory
-5.7MiB live, 513.2MiB allocated
Rules
15 952×accelerator-lowering-fma.f32
15 952×accelerator-lowering-fma.f64
15 298×accelerator-lowering-fma.f32
15 298×accelerator-lowering-fma.f64
5 744×accelerator-lowering-fma.f32
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
0515
11015
2305
01625
0730
12630
219430
3179530
0815119
03373007
19562943
228032919
369092898
084892697
01861076
15101054
215321044
353611010
08221932
Stop Event
1×done
1×iter limit
1×node limit
1×iter limit
1×node limit
1×iter limit
1×node limit
1×iter limit
1×iter limit
1×iter limit
1×unsound
Compiler

Compiled 65 to 43 computations (33.8% saved)

preprocess85.0ms (1.9%)

Memory
-7.0MiB live, 71.8MiB allocated
Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 98 to 62 computations (36.7% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...