math.log/1 on complex, real part

Time bar (total: 3.7s)

analyze46.0ms (1.2%)

Memory
7.2MiB live, 89.2MiB 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)

sample729.0ms (19.8%)

Memory
30.3MiB live, 1 487.2MiB allocated
Samples
520.0ms8 256×0valid
Precisions
Click to see histograms. Total time spent on operations: 304.0ms
ival-hypot: 188.0ms (61.9% of total)
ival-log: 106.0ms (34.9% of total)
ival-true: 6.0ms (2% of total)
ival-assert: 3.0ms (1% of total)
Bogosity

preprocess26.0ms (0.7%)

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

Useful iterations: 0 (0.0ms)

IterNodesCost
01947
13847
28047
314847
420747
522047
622247
079
0129
1139
0134
Stop Event
1×iter limit
1×saturated
1×iter limit
1×saturated
Calls
Call 1
Inputs
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
Outputs
(log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
Symmetry

(abs im)

(abs re)

(sort re im)

explain190.0ms (5.2%)

Memory
20.7MiB live, 289.2MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
1260-2(6.253591642363335e-190 2.165032398336173e-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)overflow14
↳(*.f64 im im)overflow105
sqrt.f64(sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))uflow-rescue190
↳(+.f64 (*.f64 re re) (*.f64 im im))underflow19
↳(*.f64 re re)underflow106
↳(*.f64 im im)underflow19
Confusion
Predicted +Predicted -
+1242
-0130
Precision
1.0
Recall
0.9841269841269841
Confusion?
Predicted +Predicted MaybePredicted -
+12402
-00130
Precision?
1.0
Recall?
0.9841269841269841
Freqs
test
numberfreq
0132
1124
Total Confusion?
Predicted +Predicted MaybePredicted -
+100
-000
Precision?
1.0
Recall?
1.0
Samples
121.0ms512×0valid
Compiler

Compiled 90 to 32 computations (64.4% saved)

Precisions
Click to see histograms. Total time spent on operations: 107.0ms
ival-mult: 90.0ms (84.2% of total)
ival-hypot: 8.0ms (7.5% of total)
ival-log: 6.0ms (5.6% of total)
ival-add: 2.0ms (1.9% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.5MiB live, 0.5MiB allocated
Compiler

Compiled 2 to 2 computations (0% saved)

prune1.0ms (0%)

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

Compiled 11 to 7 computations (36.4% saved)

simplify10.0ms (0.3%)

Memory
-17.9MiB live, 20.9MiB 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×lower-hypot.f32
4×lower-hypot.f64
4×lower-fma.f64
4×lift-*.f64
4×lower-fma.f32
Iterations

Useful iterations: 0 (0.0ms)

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

localize32.0ms (0.9%)

Memory
28.6MiB live, 69.2MiB allocated
Localize:

Found 4 expressions of interest:

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

Compiled 34 to 9 computations (73.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 12.0ms
ival-hypot: 5.0ms (41.5% of total)
ival-log: 3.0ms (24.9% of total)
ival-mult: 3.0ms (24.9% of total)
ival-add: 1.0ms (8.3% of total)
ival-true: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series9.0ms (0.3%)

Memory
-14.0MiB live, 25.3MiB allocated
Counts
5 → 96
Calls
Call 1
Inputs
#<alt (+.f64 (*.f64 re re) (*.f64 im im))>
#<alt (log.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))))>
#<alt (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im)))>
#<alt (*.f64 re re)>
#<alt (*.f64 im im)>
Outputs
#<alt (pow im 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (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
1.0ms
im
@inf
(+ (* re re) (* im im))
1.0ms
re
@inf
(log (sqrt (+ (* re re) (* im im))))
1.0ms
re
@0
(log (sqrt (+ (* re re) (* im im))))
1.0ms
im
@0
(log (sqrt (+ (* re re) (* im im))))
1.0ms
im
@inf
(log (sqrt (+ (* re re) (* im im))))

rewrite387.0ms (10.5%)

Memory
-2.6MiB live, 659.0MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 744×lower-fma.f64
5 744×lower-fma.f32
3 222×lower-*.f32
3 218×lower-*.f64
3 034×lower-/.f64
Iterations

Useful iterations: 0 (0.0ms)

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

simplify525.0ms (14.3%)

Memory
-4.8MiB live, 791.8MiB allocated
Algorithm
1×egg-herbie
Rules
15 952×lower-fma.f64
15 952×lower-fma.f32
5 372×lower-*.f64
5 372×lower-*.f32
3 012×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

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

eval49.0ms (1.3%)

Memory
-7.1MiB live, 145.6MiB allocated
Compiler

Compiled 14 479 to 1 296 computations (91% saved)

prune44.0ms (1.2%)

Memory
-12.5MiB live, 108.0MiB allocated
Pruning

4 alts after pruning (4 fresh and 0 done)

PrunedKeptTotal
New3484352
Fresh000
Picked101
Done000
Total3494353
Accuracy
100.0%
Counts
353 → 4
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶52.6%
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
▶99.8%
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
▶100.0%
(log.f64 (hypot.f64 re im))
▶99.3%
(log.f64 im)
Compiler

Compiled 32 to 21 computations (34.4% saved)

simplify10.0ms (0.3%)

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

Found 11 expressions of interest:

NewMetricScoreProgram
✓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 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
(log.f64 (hypot.f64 re im))
✓cost-diff5120
(hypot.f64 re im)
✓cost-diff0
(log.f64 im)
Rules
48×lower-*.f32
42×lower-*.f64
20×lower-fma.f32
16×lower-fma.f64
12×*-commutative
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01468
02868
13768
25068
35768
46068
56168
06168
Stop Event
1×iter limit
1×saturated
1×iter limit
Calls
Call 1
Inputs
(log.f64 im)
im
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
re
im
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
(fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
re
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
#s(literal 1/2 binary64)
(/.f64 re im)
im
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
#s(literal 1/2 binary64)
Outputs
(log.f64 im)
im
(log.f64 (hypot.f64 re im))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 re im)
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
re
im
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
(fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
re
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
#s(literal 1/2 binary64)
(/.f64 re im)
im
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (fma.f64 re re (*.f64 im im)))
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
re
(*.f64 im im)
im
#s(literal 1/2 binary64)

localize64.0ms (1.7%)

Memory
-19.7MiB live, 134.1MiB allocated
Localize:

Found 11 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
✓accuracy100.0%
(*.f64 im im)
✓accuracy100.0%
(fma.f64 re re (*.f64 im im))
✓accuracy52.6%
(log.f64 (fma.f64 re re (*.f64 im im)))
✓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%
(hypot.f64 re im)
✓accuracy100.0%
(log.f64 (hypot.f64 re im))
✓accuracy100.0%
(log.f64 im)
Samples
40.0ms256×0valid
Compiler

Compiled 85 to 18 computations (78.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 29.0ms
ival-log: 12.0ms (41.9% of total)
ival-mult: 7.0ms (24.4% of total)
ival-hypot: 6.0ms (20.9% of total)
ival-div: 2.0ms (7% of total)
ival-add: 2.0ms (7% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series69.0ms (1.9%)

Memory
42.3MiB live, 153.2MiB allocated
Counts
11 → 240
Calls
Call 1
Inputs
#<alt (log.f64 im)>
#<alt (hypot.f64 re im)>
#<alt (log.f64 (hypot.f64 re im))>
#<alt (log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))>
#<alt (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)>
#<alt (*.f64 #s(literal 1/2 binary64) (/.f64 re im))>
#<alt (/.f64 re im)>
#<alt (*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))>
#<alt (log.f64 (fma.f64 re re (*.f64 im im)))>
#<alt (fma.f64 re re (*.f64 im im))>
#<alt (*.f64 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 (+ (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 (* 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) (* 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)>
#<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 (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

60 calls:

TimeVariablePointExpression
26.0ms
im
@0
(log im)
19.0ms
im
@-inf
(log im)
6.0ms
im
@inf
(log im)
3.0ms
re
@inf
(log (+ (* re (* 1/2 (/ re im))) im))
1.0ms
im
@0
(log (+ (* re (* 1/2 (/ re im))) im))

rewrite422.0ms (11.5%)

Memory
4.4MiB live, 679.1MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
6 416×lower-fma.f32
6 412×lower-fma.f64
4 052×lower-*.f32
4 046×lower-*.f64
2 238×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01459
02854
17354
244354
3472454
0889954
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
11 → 460
Calls
Call 1
Inputs
(log.f64 im)
(hypot.f64 re im)
(log.f64 (hypot.f64 re im))
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
(fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im)
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(/.f64 re im)
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
(*.f64 im im)
Outputs
(log.f64 im)
(+.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 (neg.f64 im)))
(+.f64 (log.f64 (sqrt.f64 im)) (log.f64 (sqrt.f64 im)))
(-.f64 (log.f64 im) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im)))
(-.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal 1 binary64) (log.f64 im) #s(literal 0 binary64))
(neg.f64 (neg.f64 (log.f64 im)))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(exp.f64 (*.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal 1/2 binary64))) (log.f64 (fma.f64 im im (*.f64 re re)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (fma.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64) (*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))))
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 re im)
(hypot.f64 re (exp.f64 (log.f64 im)))
(hypot.f64 (exp.f64 (log.f64 im)) re)
(hypot.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(hypot.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 im)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(sqrt.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))))
(/.f64 #s(literal 1 binary64) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(/.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im))))))
(/.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) #s(literal -1 binary64))
(*.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(*.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im)))))
(*.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(*.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (neg.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(*.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (neg.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 re im))))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))) (log.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))) (log.f64 (sqrt.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im))))))
(-.f64 (log.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (log.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))) (log.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))) (log.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))))
(fma.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(neg.f64 (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 (exp.f64 #s(literal 1/2 binary64))))
(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 #s(literal 1/4 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.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 re (/.f64 (*.f64 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 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(+.f64 (log.f64 (fma.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)))) (neg.f64 (log.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(+.f64 (log.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))))
(+.f64 (log.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))) (log.f64 (/.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(+.f64 (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) (neg.f64 (log.f64 (-.f64 (*.f64 re (/.f64 (*.f64 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 (neg.f64 (fma.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 #s(literal 1 binary64) (neg.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))))
(+.f64 (log.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.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 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)))) (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 im (*.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)))))))
(+.f64 (neg.f64 (log.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))) (log.f64 (fma.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 (neg.f64 (log.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))) (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))))
(+.f64 (log.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)))) (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
(+.f64 (log.f64 (/.f64 (fma.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 (*.f64 re re)) (*.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 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (*.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im))))))) (log.f64 (fma.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (-.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im))) (*.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im)))))))
(+.f64 (log.f64 (/.f64 (fma.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)))))) (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)))))
(+.f64 (log.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)) (fma.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 im (neg.f64 im)) im)))) (log.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im)))))
(-.f64 (log.f64 (fma.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))
(-.f64 (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) (log.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))
(-.f64 #s(literal 0 binary64) (neg.f64 (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 re im) (*.f64 re #s(literal -1/2 binary64)))) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 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 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)))) (log.f64 (*.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (fma.f64 re (*.f64 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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (pow.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 9 binary64)))) (log.f64 (*.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (-.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.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 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))))))
(-.f64 (log.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im)))) (log.f64 (*.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (fma.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 im (neg.f64 im)) im)))))
(-.f64 (log.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im)))) (log.f64 (*.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (fma.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))))))))
(-.f64 (log.f64 (neg.f64 (fma.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 (neg.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(-.f64 (log.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.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 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)))) (log.f64 (+.f64 im (*.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64))))))
(-.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 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (*.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (*.f64 im im)))) (log.f64 (*.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(-.f64 (log.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (pow.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 9 binary64))) #s(literal 1 binary64))) (log.f64 (*.f64 (-.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.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 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im))) #s(literal 1 binary64))) (log.f64 (*.f64 (fma.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 im (neg.f64 im)) im)) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im))) #s(literal 1 binary64))) (log.f64 (*.f64 (fma.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))))) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) #s(literal 1 binary64))) (log.f64 (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(-.f64 (log.f64 (neg.f64 (neg.f64 (fma.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 (neg.f64 (neg.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))))
(-.f64 (log.f64 (neg.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.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 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im))))) (log.f64 (neg.f64 (+.f64 im (*.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)))))))
(-.f64 (log.f64 (-.f64 (pow.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) #s(literal 3 binary64)) (*.f64 (*.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))) (log.f64 (fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (fma.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (*.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))))))
(-.f64 (log.f64 (-.f64 (*.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))) (*.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))) (log.f64 (fma.f64 (*.f64 re re) (/.f64 (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))))
(-.f64 (log.f64 (*.f64 (fma.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 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))
(-.f64 (log.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (pow.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))) (log.f64 (-.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.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 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))) (log.f64 (fma.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 im (neg.f64 im)) im))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.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 (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64)))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im 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 re (*.f64 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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))) (log.f64 (fma.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 #s(literal -1 binary64) (log.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))) (log.f64 (*.f64 (-.f64 (*.f64 re (/.f64 (*.f64 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) (neg.f64 (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))) (log.f64 (/.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(neg.f64 (neg.f64 (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 re im) (*.f64 re #s(literal -1/2 binary64)))) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.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 3 binary64)) (pow.f64 (log.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.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 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) #s(literal 2 binary64)) (*.f64 (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) (log.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.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 2 binary64)) (pow.f64 (log.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))) #s(literal 2 binary64))) (log.f64 (*.f64 (fma.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) #s(literal 2 binary64)) (pow.f64 (log.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) #s(literal 2 binary64))) (log.f64 (*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))))
(+.f64 im (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)))
(+.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)
(+.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(exp.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))) #s(literal -1 binary64)))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))
(-.f64 (/.f64 (*.f64 im im) (+.f64 im (*.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64))))) (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (+.f64 im (*.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64))))))
(fma.f64 im #s(literal 1 binary64) (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
(fma.f64 re (/.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) 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 re (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im))) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 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 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(fma.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (/.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(fma.f64 (neg.f64 re) (*.f64 (/.f64 #s(literal -1 binary64) im) (*.f64 re #s(literal 1/2 binary64))) im)
(fma.f64 (/.f64 (*.f64 (*.f64 re re) (*.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 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(fma.f64 #s(literal 1 binary64) im (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)))
(fma.f64 #s(literal 1 binary64) (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)
(fma.f64 (/.f64 #s(literal 1 binary64) im) (*.f64 re (*.f64 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 re (*.f64 re #s(literal 1/2 binary64)))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(fma.f64 #s(literal -1 binary64) (neg.f64 im) (*.f64 re (/.f64 (*.f64 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 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 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 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(fma.f64 (*.f64 re (*.f64 re #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (*.f64 re (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im))) (/.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 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 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im)
(fma.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (/.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(fma.f64 (*.f64 re (*.f64 re #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) im) im)
(fma.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal -1 binary64)) (/.f64 re (neg.f64 im)) im)
(fma.f64 (sqrt.f64 im) (sqrt.f64 im) (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)))
(fma.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (neg.f64 im)) (neg.f64 re) im)
(fma.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) (/.f64 re im) im)
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (fma.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 im (neg.f64 im)) im))) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im))) (neg.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(neg.f64 (/.f64 (fma.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))) (neg.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(neg.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))
(neg.f64 (/.f64 (neg.f64 (fma.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))
(neg.f64 (/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))
(/.f64 (fma.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.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 re im) (*.f64 re #s(literal -1/2 binary64)))) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 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 (neg.f64 (fma.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)))) (neg.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.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 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (pow.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 9 binary64))) (*.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (-.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.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 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))))))
(/.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im))) (+.f64 im (*.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)))))
(/.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im))) (*.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (fma.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 im (neg.f64 im)) im))))
(/.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im))) (*.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (fma.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64)))))))
(/.f64 (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) (*.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 im im))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (*.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (*.f64 im im))) (*.f64 (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))
(/.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (pow.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 9 binary64))) #s(literal 1 binary64)) (*.f64 (-.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.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 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im))) #s(literal 1 binary64)) (*.f64 (fma.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 im (neg.f64 im)) im)) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))
(/.f64 (*.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))))) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) #s(literal 1 binary64)) (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))
(/.f64 (neg.f64 (neg.f64 (fma.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))))) (neg.f64 (neg.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.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 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)))) (neg.f64 (+.f64 im (*.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) #s(literal 3 binary64)) (*.f64 (*.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))) (fma.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (fma.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (*.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))))
(/.f64 (-.f64 (*.f64 (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))) (*.f64 (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #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 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)) (/.f64 (*.f64 im im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im))))
(/.f64 (*.f64 (fma.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)) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))
(/.f64 (*.f64 (fma.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (pow.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))) (-.f64 (fma.f64 (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.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 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)))))
(/.f64 (*.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.f64 im)) im))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))) (fma.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 im (neg.f64 im)) im)))
(/.f64 (*.f64 (*.f64 (fma.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 (*.f64 re re)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64)) (*.f64 im (*.f64 im im))) (*.f64 (*.f64 im (neg.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 (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) (/.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 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 re im) (*.f64 re #s(literal -1/2 binary64)))) (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re re) (*.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 re (/.f64 (*.f64 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 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im) (-.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) im)))
(*.f64 (fma.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))
(*.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (*.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(*.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (/.f64 (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im) (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))))
(*.f64 #s(literal 1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))
(*.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)) (/.f64 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)))
(*.f64 (neg.f64 (fma.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) (neg.f64 (fma.f64 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)))))
(*.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im))) (fma.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 #s(literal -1 binary64) (fma.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64)) im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)))
(*.f64 (-.f64 (*.f64 im im) (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (+.f64 im (*.f64 (/.f64 re im) (*.f64 re #s(literal -1/2 binary64))))))
(*.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))
(*.f64 (/.f64 (fma.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 (*.f64 re re)) (*.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 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))) (*.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (*.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)))))) (fma.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (-.f64 (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im)) (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im))) (*.f64 (*.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im)) (/.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 (*.f64 re (*.f64 re re)) #s(literal 1/8 binary64))) (*.f64 im (*.f64 im im))))))
(*.f64 (/.f64 (fma.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 re (-.f64 (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (*.f64 re #s(literal 1/2 binary64))) (*.f64 im im)) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im))))) (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (fma.f64 re (*.f64 re #s(literal -1/2 binary64)) (*.f64 im im))))
(*.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 re re) (*.f64 (*.f64 re re) #s(literal 1/4 binary64))) (*.f64 im im)) (*.f64 im im)) (fma.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 im (neg.f64 im)) im))) (fma.f64 re (*.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal 1/4 binary64)) (*.f64 im im))) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (*.f64 im im))))
(exp.f64 (*.f64 (log.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(neg.f64 (*.f64 (/.f64 re (neg.f64 im)) #s(literal 1/2 binary64)))
(neg.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 re (neg.f64 im))))
(neg.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (neg.f64 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)) (neg.f64 im))
(/.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 #s(literal 1 binary64) re))
(/.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 im) re))
(/.f64 (neg.f64 (*.f64 re #s(literal -1/2 binary64))) im)
(/.f64 (*.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal -1 binary64)) (neg.f64 im))
(/.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) #s(literal -1 binary64)) im)
(pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1 binary64))
(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 (neg.f64 re) (*.f64 (/.f64 #s(literal -1 binary64) im) #s(literal 1/2 binary64)))
(*.f64 (neg.f64 re) (/.f64 #s(literal 1/2 binary64) (neg.f64 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 (neg.f64 im)))
(*.f64 (/.f64 (neg.f64 re) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) im))
(*.f64 (/.f64 #s(literal 1/2 binary64) (neg.f64 im)) (neg.f64 re))
(exp.f64 (*.f64 (log.f64 (/.f64 im re)) #s(literal -1 binary64)))
(exp.f64 (fma.f64 (log.f64 re) #s(literal 1 binary64) (*.f64 (log.f64 im) #s(literal -1 binary64))))
(exp.f64 (fma.f64 (log.f64 im) #s(literal -1 binary64) (*.f64 (log.f64 re) #s(literal 1 binary64))))
(-.f64 #s(literal 0 binary64) (/.f64 re (neg.f64 im)))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 im)) (/.f64 re (neg.f64 im)))
(neg.f64 (/.f64 re (neg.f64 im)))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 re (neg.f64 im))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 im re)))
(/.f64 re im)
(/.f64 (neg.f64 re) (neg.f64 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 (neg.f64 im) re))
(/.f64 (*.f64 (neg.f64 re) #s(literal 1 binary64)) (neg.f64 im))
(/.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (neg.f64 im))
(/.f64 (/.f64 (neg.f64 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 (neg.f64 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 (neg.f64 im)))
(*.f64 (/.f64 #s(literal -1 binary64) im) (neg.f64 re))
(*.f64 (*.f64 #s(literal 1 binary64) (neg.f64 re)) (/.f64 #s(literal -1 binary64) im))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal 1/2 binary64)))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))) (log.f64 (sqrt.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))) (log.f64 (sqrt.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im))))))
(-.f64 (log.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (log.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))) (log.f64 (neg.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))) (log.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))))
(fma.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re))) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(neg.f64 (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (sqrt.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 re im))) (sqrt.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(*.f64 #s(literal 1/2 binary64) (log.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/2 binary64))
(*.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 (exp.f64 #s(literal 1/2 binary64))))
(*.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(*.f64 #s(literal 1/4 binary64) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im im (*.f64 re re)))))
(log.f64 (fma.f64 im im (*.f64 re re)))
(+.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))))
(+.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (*.f64 (+.f64 im re) (-.f64 re im)))))
(+.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (neg.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(+.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(+.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(+.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (neg.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(+.f64 #s(literal 0 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (log.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (log.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(+.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im))))))
(+.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (log.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re)))))
(+.f64 (neg.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))
(+.f64 (neg.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 re im)))) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))
(+.f64 (log.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re))) (log.f64 (+.f64 im re)))
(+.f64 (log.f64 (/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))) (log.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))))
(+.f64 (log.f64 (/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))) (log.f64 (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))))))
(+.f64 (log.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.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 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re))))))
(-.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))
(-.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 im re) (-.f64 re im))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.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 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))))
(-.f64 (log.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im))))))))) (log.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re 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 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(-.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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)))))) (log.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.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)))))))
(-.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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)))))) (log.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))))
(-.f64 (log.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (log.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(-.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(-.f64 (log.f64 (-.f64 (*.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im)))))) (log.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (*.f64 (+.f64 im re) (-.f64 re im)))))
(-.f64 (log.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) #s(literal 1 binary64))) (log.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 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) #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 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) #s(literal 1 binary64))) (log.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 re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 im re) (-.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 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.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 im re) (-.f64 re im)))))
(-.f64 (log.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))) (log.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(-.f64 (log.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))) (log.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im))))))
(-.f64 (log.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))) (log.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(-.f64 (log.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im)))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im)))) (*.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))) (log.f64 (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))))))))
(-.f64 (log.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))) (log.f64 (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))))))
(-.f64 (log.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal 1 binary64))) (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))
(-.f64 (log.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))) (log.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))) (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 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))))
(-.f64 (log.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im))))))
(-.f64 (log.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (+.f64 im re))) (log.f64 (-.f64 re im)))
(fma.f64 #s(literal -1 binary64) (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))
(fma.f64 #s(literal -1 binary64) (log.f64 (*.f64 (+.f64 im re) (-.f64 re im))) (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (*.f64 (+.f64 im re) (-.f64 re im)))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(neg.f64 (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))))
(neg.f64 (log.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) #s(literal 2 binary64)) (*.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 re im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 re im))) #s(literal 2 binary64)) (*.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) #s(literal 2 binary64)) (pow.f64 (log.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) #s(literal 2 binary64))) (log.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 re im))) #s(literal 2 binary64))) (log.f64 (*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(+.f64 (*.f64 im im) (*.f64 re re))
(+.f64 (*.f64 re re) (*.f64 im im))
(+.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(exp.f64 (*.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))))
(-.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 im re))))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(fma.f64 (*.f64 re re) (/.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(fma.f64 (*.f64 re (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(fma.f64 (*.f64 re (*.f64 re re)) (/.f64 re (*.f64 (+.f64 im re) (-.f64 re im))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re re) (*.f64 im im)) (*.f64 im im) (*.f64 im im))
(fma.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)) (*.f64 re re))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) (*.f64 im im))
(fma.f64 (/.f64 re (+.f64 im re)) (/.f64 (*.f64 re (*.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re re) (+.f64 im re)) (/.f64 (*.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re re)) (+.f64 im re)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (fma.f64 im im (*.f64 re re)) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)))) (neg.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(neg.f64 (/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(neg.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))
(neg.f64 (/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (*.f64 (+.f64 im re) (-.f64 re im))))
(/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (+.f64 im re) (-.f64 re im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im))))
(/.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re 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 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))))
(/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (+.f64 im re) (-.f64 im re)))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.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))))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re 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 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (*.f64 (*.f64 (+.f64 im re) (-.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 im re) (-.f64 re im))) (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (*.f64 im (*.f64 im (*.f64 im im))))) (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (*.f64 (+.f64 im re) (-.f64 re im))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (-.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) #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 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) #s(literal 1 binary64)) (*.f64 (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (*.f64 (+.f64 im re) (-.f64 re im))))
(/.f64 (*.f64 (*.f64 (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.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 im re) (-.f64 re im))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (neg.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))) (neg.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (-.f64 (*.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im)))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im)))) (*.f64 (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))))) (fma.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (fma.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (+.f64 im re) (-.f64 re im)))) (*.f64 (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im))))) (fma.f64 re (/.f64 (*.f64 re (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 (*.f64 im (*.f64 im (*.f64 im im))) (*.f64 (+.f64 im re) (-.f64 re im)))))
(/.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) #s(literal 1 binary64)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im (*.f64 im im)) (*.f64 (*.f64 im im) (*.f64 im (*.f64 im (*.f64 im im)))))))) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re 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 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.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)))))
(/.f64 (*.f64 (*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.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))))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im)))) (fma.f64 (*.f64 im (*.f64 im (*.f64 im im))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re 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 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im)))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im (*.f64 im im)))))
(/.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (+.f64 im re)) (-.f64 re im))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re)))) #s(literal -1 binary64))
(*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im)))))
(*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 (*.f64 (+.f64 im re) (-.f64 re im)) (*.f64 (+.f64 im re) (-.f64 re im))))
(*.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))
(*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))) (*.f64 (fma.f64 im im (*.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))) (/.f64 (fma.f64 im im (*.f64 re re)) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))))
(*.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))))
(*.f64 (neg.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))))))
(*.f64 (neg.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 im re) (-.f64 re im)))))
(*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im))))) (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))))
(*.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 im re) (-.f64 im re))))
(*.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 im re)) (+.f64 im re))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im)))) (fma.f64 im im (*.f64 re re)))
(*.f64 (/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))) (*.f64 (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))))) (fma.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (-.f64 (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re))) (*.f64 re (*.f64 re (*.f64 re re)))) (*.f64 (*.f64 re re) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re))))))
(*.f64 (/.f64 (fma.f64 im (*.f64 im (*.f64 im (*.f64 im (*.f64 im im)))) (*.f64 (*.f64 re (*.f64 re re)) (*.f64 re (*.f64 re re)))) (*.f64 (fma.f64 im (*.f64 im (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 (+.f64 im re) (-.f64 re im)))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))))) (-.f64 (*.f64 re (*.f64 re (*.f64 re re))) (*.f64 (*.f64 im im) (*.f64 (+.f64 im re) (-.f64 im re)))))
(*.f64 (/.f64 (*.f64 (fma.f64 im im (*.f64 re re)) (*.f64 (+.f64 im re) (-.f64 re im))) (*.f64 (fma.f64 re (*.f64 re re) (*.f64 im (*.f64 im im))) (-.f64 (*.f64 re (*.f64 re re)) (*.f64 im (*.f64 im im))))) (fma.f64 re (*.f64 re (*.f64 re re)) (*.f64 (*.f64 im im) (fma.f64 im im (*.f64 re re)))))
(exp.f64 (log.f64 (*.f64 im im)))
(exp.f64 (*.f64 (log.f64 (*.f64 im im)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 (log.f64 im))) #s(literal 2 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 im) #s(literal 1 binary64)) #s(literal 2 binary64)))
(exp.f64 (fma.f64 (log.f64 im) #s(literal 1 binary64) (*.f64 (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 (log.f64 im)) #s(literal 2 binary64))
(*.f64 im im)
(*.f64 (exp.f64 (log.f64 im)) (exp.f64 (log.f64 im)))

simplify458.0ms (12.4%)

Memory
1.8MiB live, 816.9MiB allocated
Algorithm
1×egg-herbie
Rules
15 298×lower-fma.f64
15 298×lower-fma.f32
4 906×lower-+.f64
4 906×lower-+.f32
3 894×lower-*.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03372955
19552891
228032867
369102846
084902645
Stop Event
1×iter limit
1×node limit
Counts
240 → 233
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)))
(+ (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 (* 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) (* 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)
(* 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))))
(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)
(+ (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 (* 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 (/.f64 (*.f64 #s(literal -1/8 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (*.f64 (*.f64 re re) (*.f64 re re))) (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/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (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)))))))
(fma.f64 (neg.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))))))))
(neg.f64 (fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 (*.f64 im im) (*.f64 im im)) (*.f64 (*.f64 re re) (*.f64 re re))) (fma.f64 im (/.f64 (*.f64 im #s(literal 1/2 binary64)) (*.f64 re re)) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) 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 im (*.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im im) (*.f64 re (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) re))) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (*.f64 im im) (fma.f64 (*.f64 im im) (fma.f64 (*.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))))))
(fma.f64 im (*.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)))) 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 (*.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 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (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)) (neg.f64 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 (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))) (neg.f64 im))
(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 re (*.f64 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 (*.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 #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)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)) (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 (*.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 (/.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 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 re (*.f64 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 re (*.f64 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 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (log.f64 im)))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (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 (*.f64 re (*.f64 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 (/.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) (* 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/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 re (*.f64 re (fma.f64 re (*.f64 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 (*.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))) (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))) (* 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)))))
(fma.f64 #s(literal 2 binary64) (*.f64 im (/.f64 im (*.f64 re re))) (-.f64 (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)))))))
(-.f64 (fma.f64 (*.f64 im im) (fma.f64 (*.f64 im 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))) (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 re (*.f64 re (/.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/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 re (*.f64 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)))))))
(-.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))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/24 binary64) (pow.f64 im #s(literal 6 binary64))) (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 im (/.f64 (*.f64 im (*.f64 (*.f64 re re) #s(literal -1/2 binary64))) (*.f64 im im)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(-.f64 im (/.f64 (*.f64 im (*.f64 (*.f64 re re) #s(literal -1/2 binary64))) (*.f64 im im)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(-.f64 im (/.f64 (*.f64 im (*.f64 (*.f64 re re) #s(literal -1/2 binary64))) (*.f64 im 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))
(* 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)
(* 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 #s(literal 1/2 binary64) (log.f64 (*.f64 im im)) (*.f64 re (*.f64 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))))))
(+ (* 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 #s(literal 1/2 binary64) (log.f64 (*.f64 im im)) (*.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)))))
(* -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)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 im im)) (*.f64 re re)) (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 (*.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 (/.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)) (*.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)))))
(* -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 re (*.f64 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 re (*.f64 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)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (*.f64 re re)) (*.f64 im im)) (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 (*.f64 re (*.f64 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 (/.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 re (*.f64 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 re) (/.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)))
(+ (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 re (*.f64 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 (*.f64 im im) (fma.f64 (/.f64 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (*.f64 re re))) (*.f64 #s(literal 2 binary64) (log.f64 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 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/2 binary64) (/.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 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/2 binary64) (/.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 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/2 binary64) (/.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 (*.f64 im im) (*.f64 (*.f64 re re) (*.f64 re re))) #s(literal -1/2 binary64) (/.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 (*.f64 im 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 (log.f64 im) #s(literal 2 binary64))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 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 re) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (*.f64 (log.f64 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 re) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (log.f64 im) #s(literal 2 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 re (fma.f64 re (/.f64 (*.f64 (*.f64 re re) #s(literal -1/2 binary64)) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 re (*.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 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (*.f64 re re) (fma.f64 (*.f64 re re) (/.f64 #s(literal -1/2 binary64) (*.f64 (*.f64 im im) (*.f64 im im))) (/.f64 #s(literal 1 binary64) (*.f64 im im))) (/.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))
(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)

eval86.0ms (2.3%)

Memory
22.1MiB live, 211.7MiB allocated
Compiler

Compiled 20 567 to 1 798 computations (91.3% saved)

prune71.0ms (1.9%)

Memory
-2.7MiB live, 192.8MiB allocated
Pruning

4 alts after pruning (0 fresh and 4 done)

PrunedKeptTotal
New6930693
Fresh000
Picked044
Done000
Total6934697
Accuracy
100.0%
Counts
697 → 4
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓52.6%
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
✓99.8%
(log.f64 (fma.f64 re (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) im))
✓100.0%
(log.f64 (hypot.f64 re im))
✓99.3%
(log.f64 im)
Compiler

Compiled 67 to 39 computations (41.8% saved)

regimes23.0ms (0.6%)

Memory
-4.0MiB live, 45.6MiB allocated
Counts
5 → 1
Calls
Call 1
Inputs
(log.f64 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:

9.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 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)

regimes15.0ms (0.4%)

Memory
2.2MiB live, 40.3MiB allocated
Counts
4 → 1
Calls
Call 1
Inputs
(log.f64 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:

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

Compiled 46 to 28 computations (39.1% saved)

regimes12.0ms (0.3%)

Memory
-7.5MiB live, 30.7MiB allocated
Accuracy

Total -30.0b remaining (-6369.1%)

Threshold costs -30b (-6369.1%)

Counts
2 → 1
Calls
Call 1
Inputs
(log.f64 im)
(*.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))
Outputs
(log.f64 im)
Calls

7 calls:

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

Compiled 46 to 28 computations (39.1% saved)

simplify6.0ms (0.2%)

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

Useful iterations: 0 (0.0ms)

IterNodesCost
01015
11115
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)
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)

soundness353.0ms (9.6%)

Memory
-10.5MiB live, 296.9MiB allocated
Rules
15 952×lower-fma.f64
15 952×lower-fma.f32
5 744×lower-fma.f64
5 744×lower-fma.f32
5 372×lower-*.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01861076
15101054
215321044
353611010
08221932
0730
01230
13130
219930
3179830
0814919
Stop Event
1×done
1×iter limit
1×node limit
1×iter limit
1×iter limit
1×node limit
Compiler

Compiled 38 to 24 computations (36.8% saved)

preprocess44.0ms (1.2%)

Memory
16.2MiB live, 98.8MiB allocated
Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 92 to 58 computations (37% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...