This is an archive of the discontinued LLVM Phabricator instance.

Differential D29587

[DAGCombiner] mulhi + 1 never overflow.
ClosedPublic

Authored by deadalnix on Feb 6 2017, 9:13 AM.

Details

Reviewers
spatel
RKSimon
zvi
mkuper
craig.topper
bkramer
aaboud
efriedma
Commits
rG71f511fd1ec9: [DAGCombiner] mulhi + 1 never overflow.
rL296711: [DAGCombiner] mulhi + 1 never overflow.
Summary

This can be used to optimize large multiplications after legalization.

Depends on D29565

Diff Detail

Event Timeline

deadalnix created this revision.Feb 6 2017, 9:13 AM
efriedma added a subscriber: efriedma.Feb 6 2017, 12:19 PM

Is it possible to write a testcase which isn't quite so big?

lib/CodeGen/SelectionDAG/SelectionDAG.cpp
2779

Missing a check for which result you're using from the UMUL_LOHI. (I think this transform is only valid for the high result.)

2780

Could you just write this as "~N1Zero == 1"?

deadalnix added a comment.Feb 6 2017, 1:30 PM

There is a nice small test case in adde-carry.ll , but it needs D29528 in addition to that one to trigger.

lib/CodeGen/SelectionDAG/SelectionDAG.cpp
2779

You are absolutely right.

2780

I was wondering if I should match 0 or not. I went for the safe road and matched 0.

deadalnix updated this revision to Diff 87305.Feb 6 2017, 2:23 PM

Only match mulhi

Harbormaster completed remote builds in B3692: Diff 87305.Feb 6 2017, 2:23 PM
efriedma added inline comments.Feb 6 2017, 2:39 PM
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
2781

Another question: is there some reason to expect that N0 is the multiply, rather than N1?

deadalnix added inline comments.Feb 6 2017, 2:45 PM
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
2781

The specific case I'm looking at is fma like construct on big ints. After legalization you end up with combination of adde and mulhi no the left hand side. But indeed, that's an option to do it the other way around.

deadalnix added inline comments.Feb 6 2017, 4:11 PM
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
2781

So i tried to do it both ways. I see no difference in any of my tests cases, but, on the other hand, I see no reason not to do it. What do you think ?

deadalnix updated this revision to Diff 87533.Feb 7 2017, 3:02 PM

Match the pattern both ways.

Harbormaster completed remote builds in B3755: Diff 87533.Feb 7 2017, 3:02 PM
efriedma added inline comments.Feb 15 2017, 1:44 PM
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
2781

I don't really like duplicating the code like that... but I guess we need to do it that way to avoid calling computeKnownBits when we don't use the result?

You can probably construct a smaller testcase to trigger this; maybe something like (uint64_t)(c == 0) + (((uint64_t)a * (uint64_t)b) >> 32), where a, b, and c are 32-bit integers.

deadalnix updated this revision to Diff 90233.Mar 1 2017, 2:46 PM

Update so it doesn't depend on D29565 anymore and has its own test.

efriedma accepted this revision.Mar 1 2017, 2:59 PM

LGTM.

test/CodeGen/X86/overflow.ll
38 ↗(On Diff #90233)

Maybe change this test to return %7 rather than just one bit of the high half of %7, so the code isn't completely dead? Not really important.

This revision is now accepted and ready to land.Mar 1 2017, 2:59 PM
deadalnix added inline comments.Mar 1 2017, 3:10 PM
test/CodeGen/X86/overflow.ll
38 ↗(On Diff #90233)

The code is dead either way, we shift right to get the carry.

efriedma added inline comments.Mar 1 2017, 3:13 PM
test/CodeGen/X86/overflow.ll
38 ↗(On Diff #90233)

I mean make the function return i128, and make the last instruction "ret i128 %7", so we return the 64-bit sum in RAX, and zero in RDX.

deadalnix added inline comments.Mar 1 2017, 3:34 PM
test/CodeGen/X86/overflow.ll
38 ↗(On Diff #90233)

Patch incoming.

deadalnix updated this revision to Diff 90250.Mar 1 2017, 3:51 PM

Improve test case

Closed by commit rL296711: [DAGCombiner] mulhi + 1 never overflow. (authored by deadalnix). · Explain WhyMar 1 2017, 3:56 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lib/
CodeGen/
SelectionDAG/
5 lines
test/
CodeGen/
X86/
2193 lines
19 lines
166 lines

Diff 87305

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,769 Lines • ▼ Show 20 Lines if (N1Zero.getBoolValue()) {
computeKnownBits(N0, N0Zero, N0One); computeKnownBits(N0, N0Zero, N0One);
bool overflow; bool overflow;
(~N0Zero).uadd_ov(~N1Zero, overflow); (~N0Zero).uadd_ov(~N1Zero, overflow);
if (!overflow) if (!overflow)
return OFK_Never; return OFK_Never;
} }
// mulhi + 1 never overflow
if (N0.getOpcode() == ISD::UMUL_LOHI && N0.getResNo() == 1 &&
efriedmaUnsubmitted
Not Done
ReplyInline Actions

Missing a check for which result you're using from the UMUL_LOHI. (I think this transform is only valid for the high result.)

efriedma: Missing a check for which result you're using from the UMUL_LOHI. (I think this transform is…
deadalnixAuthorUnsubmitted
Not Done
ReplyInline Actions

You are absolutely right.

deadalnix: You are absolutely right.
(~N1Zero & 0x01) == ~N1Zero)
efriedmaUnsubmitted
Not Done
ReplyInline Actions

Could you just write this as "~N1Zero == 1"?

efriedma: Could you just write this as "~N1Zero == 1"?
deadalnixAuthorUnsubmitted
Not Done
ReplyInline Actions

I was wondering if I should match 0 or not. I went for the safe road and matched 0.

deadalnix: I was wondering if I should match 0 or not. I went for the safe road and matched 0.
return OFK_Never;
efriedmaUnsubmitted
Not Done
ReplyInline Actions

Another question: is there some reason to expect that N0 is the multiply, rather than N1?

efriedma: Another question: is there some reason to expect that N0 is the multiply, rather than N1?
deadalnixAuthorUnsubmitted
Not Done
ReplyInline Actions

The specific case I'm looking at is fma like construct on big ints. After legalization you end up with combination of adde and mulhi no the left hand side. But indeed, that's an option to do it the other way around.

deadalnix: The specific case I'm looking at is fma like construct on big ints. After legalization you end…
deadalnixAuthorUnsubmitted
Not Done
ReplyInline Actions

So i tried to do it both ways. I see no difference in any of my tests cases, but, on the other hand, I see no reason not to do it. What do you think ?

deadalnix: So i tried to do it both ways. I see no difference in any of my tests cases, but, on the other…
efriedmaUnsubmitted
Not Done
ReplyInline Actions

I don't really like duplicating the code like that... but I guess we need to do it that way to avoid calling computeKnownBits when we don't use the result?

You can probably construct a smaller testcase to trigger this; maybe something like (uint64_t)(c == 0) + (((uint64_t)a * (uint64_t)b) >> 32), where a, b, and c are 32-bit integers.

efriedma: I don't really like duplicating the code like that... but I guess we need to do it that way to…
return OFK_Sometime; return OFK_Sometime;
} }
bool SelectionDAG::isKnownToBeAPowerOfTwo(SDValue Val) const { bool SelectionDAG::isKnownToBeAPowerOfTwo(SDValue Val) const {
EVT OpVT = Val.getValueType(); EVT OpVT = Val.getValueType();
unsigned BitWidth = OpVT.getScalarSizeInBits(); unsigned BitWidth = OpVT.getScalarSizeInBits();
// Is the constant a known power of 2? // Is the constant a known power of 2?
▲ Show 20 Lines • Show All 4,892 Lines • Show Last 20 Lines

test/CodeGen/X86/mul-i1024.ll

Show First 20 Lines • Show All 4,382 Lines • ▼ Show 20 Lines
; X64-LABEL: test_1024: ; X64-LABEL: test_1024:
; X64: # BB#0: ; X64: # BB#0:
; X64-NEXT: pushq %rbp ; X64-NEXT: pushq %rbp
; X64-NEXT: pushq %r15 ; X64-NEXT: pushq %r15
; X64-NEXT: pushq %r14 ; X64-NEXT: pushq %r14
; X64-NEXT: pushq %r13 ; X64-NEXT: pushq %r13
; X64-NEXT: pushq %r12 ; X64-NEXT: pushq %r12
; X64-NEXT: pushq %rbx ; X64-NEXT: pushq %rbx
; X64-NEXT: subq $360, %rsp # imm = 0x168 ; X64-NEXT: subq $352, %rsp # imm = 0x160
; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq 48(%rdi), %r9 ; X64-NEXT: movq 48(%rdi), %r8
; X64-NEXT: movq %r9, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r8, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq 40(%rdi), %rcx ; X64-NEXT: movq 40(%rdi), %rcx
; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq 32(%rdi), %rax ; X64-NEXT: movq 32(%rdi), %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdi, %r10 ; X64-NEXT: movq %rdi, %r13
; X64-NEXT: xorl %r8d, %r8d ; X64-NEXT: xorl %r9d, %r9d
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r9
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r9
; X64-NEXT: movq %rax, %rcx ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: addq %rdi, %rcx ; X64-NEXT: addq %rbx, %rcx
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: addq %r11, %rcx ; X64-NEXT: addq %r11, %rcx
; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdi, %rbp ; X64-NEXT: adcq %rbx, %rbp
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: movq %rbx, %rcx
; X64-NEXT: addq %rbx, %rbp
; X64-NEXT: sbbq %rbx, %rbx ; X64-NEXT: sbbq %rbx, %rbx
; X64-NEXT: andl $1, %ebx ; X64-NEXT: andl $1, %ebx
; X64-NEXT: addq %rax, %rbp ; X64-NEXT: addq %rax, %rbp
; X64-NEXT: adcq %rdx, %rbx ; X64-NEXT: adcq %rdx, %rbx
; X64-NEXT: movq %r9, %rax ; X64-NEXT: movq %r8, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r9
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r11, %r13 ; X64-NEXT: movq %r11, %r12
; X64-NEXT: addq %rax, %r13 ; X64-NEXT: addq %rax, %r12
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %rdi, %r15 ; X64-NEXT: movq %rcx, %r8
; X64-NEXT: movq %r15, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r8, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %rdx, %rax ; X64-NEXT: adcq %rdx, %rax
; X64-NEXT: addq %rbp, %r13 ; X64-NEXT: addq %rbp, %r12
; X64-NEXT: movq %r13, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r12, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %rbx, %rax ; X64-NEXT: adcq %rbx, %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rsi, %r8 ; X64-NEXT: movq (%rsi), %rax
; X64-NEXT: movq (%r8), %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: xorl %ebp, %ebp ; X64-NEXT: xorl %ebp, %ebp
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rax, %r14 ; X64-NEXT: movq %rax, %r10
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq 8(%r8), %rax ; X64-NEXT: movq 8(%rsi), %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %rbp
; X64-NEXT: xorl %r9d, %r9d ; X64-NEXT: xorl %r9d, %r9d
; X64-NEXT: movq %rax, %r12 ; X64-NEXT: movq %rax, %r15
; X64-NEXT: addq %rcx, %r12 ; X64-NEXT: addq %rcx, %r15
; X64-NEXT: movq %rdx, %rbp ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: addq %r14, %r12 ; X64-NEXT: addq %r10, %r15
; X64-NEXT: movq %rcx, %rbx ; X64-NEXT: adcq %rcx, %rbp
; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, %rdi
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: addq %rbp, %rbx ; X64-NEXT: sbbq %rbx, %rbx
; X64-NEXT: sbbq %rbp, %rbp ; X64-NEXT: andl $1, %ebx
; X64-NEXT: andl $1, %ebp ; X64-NEXT: addq %rax, %rbp
; X64-NEXT: addq %rax, %rbx ; X64-NEXT: adcq %rdx, %rbx
; X64-NEXT: adcq %rdx, %rbp ; X64-NEXT: movq 16(%rsi), %rax
; X64-NEXT: movq 16(%r8), %rax ; X64-NEXT: movq %rsi, %r14
; X64-NEXT: movq %r8, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r14, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %r9 ; X64-NEXT: mulq %r9
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r14, %r9 ; X64-NEXT: movq %r10, %rcx
; X64-NEXT: addq %rax, %r9 ; X64-NEXT: movq %rcx, %rsi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: addq %rax, %rsi
; X64-NEXT: adcq %rdx, %rax ; X64-NEXT: movq %rdi, %r9
; X64-NEXT: addq %rbx, %r9 ; X64-NEXT: adcq %rdx, %r9
; X64-NEXT: adcq %rbp, %rax ; X64-NEXT: addq %rbp, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rsi, %r10
; X64-NEXT: movq %r11, %rax ; X64-NEXT: adcq %rbx, %r9
; X64-NEXT: movq %r11, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r11, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: addq %r14, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: adcq %rcx, %r15 ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: movq %r15, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: adcq %rdi, %r8
; X64-NEXT: movq (%r10), %rax ; X64-NEXT: movq %r8, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r13, %rbp
; X64-NEXT: movq (%rbp), %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: xorl %r15d, %r15d ; X64-NEXT: xorl %r8d, %r8d
; X64-NEXT: mulq %r15 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %r14, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: movq %r14, %rdi
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: adcq %rcx, %rax ; X64-NEXT: adcq %rdi, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq 32(%r8), %rax ; X64-NEXT: movq 32(%r14), %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %r15 ; X64-NEXT: mulq %r8
; X64-NEXT: xorl %r8d, %r8d ; X64-NEXT: movq %rax, %r13
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, (%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: movq %rbx, %rcx
; X64-NEXT: movq %rbx, %r14 ; X64-NEXT: movq %rbx, %r14
; X64-NEXT: addq %rax, %rcx ; X64-NEXT: addq %r13, %rax
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: adcq %rdx, %rax ; X64-NEXT: adcq %rdx, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: addq %rdi, %r11 ; X64-NEXT: addq %rcx, %r11
; X64-NEXT: movq %r11, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r11, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdi, %r11 ; X64-NEXT: movq %rcx, %r8
; X64-NEXT: movq %r11, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r8, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: adcq %r12, %rax ; X64-NEXT: adcq %r15, %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r9, %r13 ; X64-NEXT: adcq %r10, %r12
; X64-NEXT: movq %r13, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r12, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r9, %rdi ; X64-NEXT: movq %r10, %rcx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: adcq %rbp, %rax ; X64-NEXT: adcq %r9, %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rbp, %r9 ; X64-NEXT: movq %r9, %r10
; X64-NEXT: movq 8(%r10), %rax ; X64-NEXT: movq 8(%rbp), %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r10, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rbp, %rdi
; X64-NEXT: mulq %r8
; X64-NEXT: xorl %ecx, %ecx
; X64-NEXT: movq %rax, %r15
; X64-NEXT: addq %rsi, %r15
; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: adcq $0, %rbx
; X64-NEXT: addq %r14, %r15
; X64-NEXT: movq %rsi, %rbp
; X64-NEXT: movq %rsi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rbp
; X64-NEXT: addq %rbx, %rbp
; X64-NEXT: sbbq %r8, %r8
; X64-NEXT: andl $1, %r8d
; X64-NEXT: addq %rax, %rbp
; X64-NEXT: adcq %rdx, %r8
; X64-NEXT: movq 16(%r10), %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r14, %rbx
; X64-NEXT: addq %rax, %rbx
; X64-NEXT: movq %rsi, %r10
; X64-NEXT: adcq %rdx, %r10
; X64-NEXT: addq %rbp, %rbx
; X64-NEXT: adcq %r8, %r10
; X64-NEXT: movq %r14, %rax
; X64-NEXT: movq %r14, (%rsp) # 8-byte Spill
; X64-NEXT: addq %r11, %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r15, %rcx
; X64-NEXT: adcq %rcx, %r12
; X64-NEXT: movq %r12, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %rbx, %rdi
; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rbx, %r8
; X64-NEXT: adcq %r10, %r9
; X64-NEXT: movq %r9, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r13 # 8-byte Reload
; X64-NEXT: movq 40(%r13), %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: xorl %edx, %edx ; X64-NEXT: xorl %edx, %edx
; X64-NEXT: mulq %rdx ; X64-NEXT: mulq %rdx
; X64-NEXT: xorl %r11d, %r11d ; X64-NEXT: xorl %r9d, %r9d
; X64-NEXT: movq %rax, %rsi ; X64-NEXT: movq %rax, %r12
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r9 # 8-byte Reload ; X64-NEXT: addq %rsi, %r12
; X64-NEXT: addq %r9, %rsi ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: addq %r14, %r12
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: adcq %rsi, %rbp
; X64-NEXT: addq %rdi, %rsi ; X64-NEXT: movq %rsi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r9, %rbp ; X64-NEXT: sbbq %rbx, %rbx
; X64-NEXT: andl $1, %ebx
; X64-NEXT: addq %rax, %rbp
; X64-NEXT: adcq %rdx, %rbx
; X64-NEXT: movq 16(%rdi), %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %r9
; X64-NEXT: xorl %edi, %edi
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r14, %r9
; X64-NEXT: addq %rax, %r9
; X64-NEXT: adcq %rdx, %rsi
; X64-NEXT: addq %rbp, %r9
; X64-NEXT: movq %r9, %rdx
; X64-NEXT: adcq %rbx, %rsi
; X64-NEXT: movq %rsi, %rax
; X64-NEXT: movq %r14, %rsi
; X64-NEXT: movq %r14, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: addq %r8, %rsi
; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r12, %r15
; X64-NEXT: movq %r15, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %rdx, %rcx
; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, %r15
; X64-NEXT: adcq %rax, %r10
; X64-NEXT: movq %r10, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rax, %r10
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq 40(%rsi), %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rdi
; X64-NEXT: xorl %r8d, %r8d
; X64-NEXT: movq %rax, %rcx
; X64-NEXT: movq (%rsp), %rdi # 8-byte Reload
; X64-NEXT: addq %rdi, %rcx
; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: addq %rbx, %rbp ; X64-NEXT: addq %r13, %rcx
; X64-NEXT: adcq %rdi, %rbp
; X64-NEXT: sbbq %rbx, %rbx ; X64-NEXT: sbbq %rbx, %rbx
; X64-NEXT: andl $1, %ebx ; X64-NEXT: andl $1, %ebx
; X64-NEXT: addq %rax, %rbp ; X64-NEXT: addq %rax, %rbp
; X64-NEXT: adcq %rdx, %rbx ; X64-NEXT: adcq %rdx, %rbx
; X64-NEXT: movq 48(%r13), %rax ; X64-NEXT: movq 48(%rsi), %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %r11 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdi, %r15 ; X64-NEXT: movq %r13, %r8
; X64-NEXT: movq %rdi, %r11 ; X64-NEXT: addq %rax, %r8
; X64-NEXT: addq %rax, %r15 ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq %r9, %rdi ; X64-NEXT: adcq %rdx, %rax
; X64-NEXT: adcq %rdx, %rdi ; X64-NEXT: addq %rbp, %r8
; X64-NEXT: addq %rbp, %r15 ; X64-NEXT: adcq %rbx, %rax
; X64-NEXT: adcq %rbx, %rdi ; X64-NEXT: movq %r13, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: addq %r11, %r14 ; X64-NEXT: addq %r13, %r14
; X64-NEXT: movq %r14, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r14, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %rsi, %rcx ; X64-NEXT: adcq %rcx, %r12
; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r12, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r15, %r8 ; X64-NEXT: adcq %r8, %r15
; X64-NEXT: movq %r8, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r15, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %rdi, %r10 ; X64-NEXT: adcq %rax, %r10
; X64-NEXT: movq %r10, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r10, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r14 # 8-byte Reload ; X64-NEXT: movq %rax, %rdx
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: addq %r11, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: addq %r13, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: adcq %r9, %rax ; X64-NEXT: adcq %rdi, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: addq %r11, %rax ; X64-NEXT: addq %r13, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: movq %rsi, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r8 # 8-byte Folded Reload
; X64-NEXT: movq %r15, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r8, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload
; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r8
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: movq 56(%rax), %rsi ; X64-NEXT: movq 56(%rax), %r11
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdi, %r10 ; X64-NEXT: movq %rdi, %r9
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rbx, %rbp ; X64-NEXT: addq %rsi, %rbx
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %r8 ; X64-NEXT: movq %rax, %r10
; X64-NEXT: addq %rbp, %r8 ; X64-NEXT: addq %rbx, %r10
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: adcq %rbp, %rsi
; X64-NEXT: addq %rdi, %rbx ; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: sbbq %rdi, %rdi ; X64-NEXT: andl $1, %ecx
; X64-NEXT: andl $1, %edi ; X64-NEXT: movq %r11, %rax
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: mulq %rdi
; X64-NEXT: mulq %rcx ; X64-NEXT: movq %rdi, %r14
; X64-NEXT: movq %rcx, %r11 ; X64-NEXT: addq %rsi, %rax
; X64-NEXT: addq %rbx, %rax ; X64-NEXT: adcq %rcx, %rdx
; X64-NEXT: adcq %rdi, %rdx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r15 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r15 # 8-byte Reload
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r12 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r12 # 8-byte Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r12 # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r12 # 8-byte Folded Reload
; X64-NEXT: addq %rax, %r15 ; X64-NEXT: addq %rax, %r15
; X64-NEXT: adcq %rdx, %r12 ; X64-NEXT: adcq %rdx, %r12
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq %r10, %rsi ; X64-NEXT: movq %r9, %rcx
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %r10 ; X64-NEXT: movq %rdx, %r9
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %rbp ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %r10, %rbx ; X64-NEXT: addq %r9, %rbx
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq %rdi, %r10 ; X64-NEXT: mulq %r14
; X64-NEXT: mulq %r11 ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: addq %rbx, %rax ; X64-NEXT: addq %rbx, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: adcq %rbp, %rcx
; X64-NEXT: addq %rbp, %rdi
; X64-NEXT: sbbq %rbp, %rbp ; X64-NEXT: sbbq %rbp, %rbp
; X64-NEXT: andl $1, %ebp ; X64-NEXT: andl $1, %ebp
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rsi, %rbx
; X64-NEXT: movq %rcx, %rsi ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: mulq %r11 ; X64-NEXT: mulq %r14
; X64-NEXT: movq %rdx, %r13 ; X64-NEXT: movq %rdx, %r13
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rsi
; X64-NEXT: addq %rdi, %rbx ; X64-NEXT: addq %rcx, %rsi
; X64-NEXT: adcq %rbp, %r13 ; X64-NEXT: adcq %rbp, %r13
; X64-NEXT: addq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload
; X64-NEXT: addq %r9, %rbx ; X64-NEXT: addq %r8, %rsi
; X64-NEXT: adcq %r8, %r13 ; X64-NEXT: adcq %r10, %r13
; X64-NEXT: adcq $0, %r15 ; X64-NEXT: adcq $0, %r15
; X64-NEXT: adcq $0, %r12 ; X64-NEXT: adcq $0, %r12
; X64-NEXT: movq %r10, %rbp ; X64-NEXT: movq %rdi, %rbp
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r9 # 8-byte Reload
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %r9
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r10
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: movq %rsi, %r8 ; X64-NEXT: movq %rbx, %r14
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %r9
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rcx, %rdi ; X64-NEXT: addq %rcx, %rbx
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rdi
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: movq 24(%rax), %r14 ; X64-NEXT: movq 24(%rax), %rcx
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %r14 ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rcx, %rbp
; X64-NEXT: movq %rbp, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rdi, %rax ; X64-NEXT: movq %rax, %r8
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: addq %rbx, %r8
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rdi, %rcx
; X64-NEXT: addq %rsi, %rcx ; X64-NEXT: sbbq %rdi, %rdi
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: andl $1, %edi
; X64-NEXT: andl $1, %esi ; X64-NEXT: movq %r14, %rax
; X64-NEXT: movq %r8, %rax ; X64-NEXT: mulq %rbp
; X64-NEXT: mulq %r14
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rsi, %rdx ; X64-NEXT: adcq %rdi, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbx # 8-byte Reload
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r11 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r14 # 8-byte Reload
; X64-NEXT: addq %r11, %rbp ; X64-NEXT: adcq %r14, %rbp
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: addq %rax, %rbx
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: adcq %rdx, %rbp
; X64-NEXT: addq %rax, %rbp ; X64-NEXT: addq %rsi, %r10
; X64-NEXT: adcq %rdx, %rsi ; X64-NEXT: movq %r10, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: addq %rbx, %r9 ; X64-NEXT: adcq %r13, %r8
; X64-NEXT: movq %r9, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r8, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r13, %rdi ; X64-NEXT: adcq $0, %rbx
; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: addq %r15, %rbx
; X64-NEXT: addq %r15, %rbp ; X64-NEXT: adcq %r12, %rbp
; X64-NEXT: adcq %r12, %rsi ; X64-NEXT: movl $0, %r8d
; X64-NEXT: movl $0, %r10d ; X64-NEXT: adcq $0, %r8
; X64-NEXT: adcq $0, %r10 ; X64-NEXT: sbbq %r10, %r10
; X64-NEXT: sbbq %r15, %r15 ; X64-NEXT: andl $1, %r10d
; X64-NEXT: andl $1, %r15d
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq %r9, %rsi
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %r12 ; X64-NEXT: movq %rdx, %r9
; X64-NEXT: movq %rax, %r13 ; X64-NEXT: movq %rax, %r15
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r8 # 8-byte Reload ; X64-NEXT: movq %r11, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: addq %r12, %rdi ; X64-NEXT: addq %r9, %rdi
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %r14 ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rdx, %r9
; X64-NEXT: addq %rdi, %r9 ; X64-NEXT: movq %rax, %r13
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: addq %rdi, %r13
; X64-NEXT: addq %rbx, %rcx ; X64-NEXT: adcq %rsi, %r9
; X64-NEXT: sbbq %rdi, %rdi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %edi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: mulq %r14 ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %r14, %r12 ; X64-NEXT: movq %rcx, %r12
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %r9, %rax
; X64-NEXT: adcq %rdi, %rdx ; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: addq %r11, %rcx ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload ; X64-NEXT: adcq %r14, %rsi
; X64-NEXT: addq %rax, %rcx ; X64-NEXT: addq %rax, %rcx
; X64-NEXT: adcq %rdx, %rdi ; X64-NEXT: adcq %rdx, %rsi
; X64-NEXT: addq %rbp, %r13 ; X64-NEXT: addq %rbx, %r15
; X64-NEXT: adcq %rsi, %r9 ; X64-NEXT: adcq %rbp, %r13
; X64-NEXT: adcq %r10, %rcx ; X64-NEXT: adcq %r8, %rcx
; X64-NEXT: adcq %r15, %rdi ; X64-NEXT: adcq %r10, %rsi
; X64-NEXT: addq {{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload
; X64-NEXT: movq %r15, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload
; X64-NEXT: movq %r13, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r13, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r9 # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: movq %r9, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: movq %rdi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rsi, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: mulq %rdi ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rax, %r9
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: movq 24(%rax), %r8 ; X64-NEXT: movq 24(%rax), %rbp
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: movq %r8, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rbp, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdi, %r13 ; X64-NEXT: movq %rsi, %r14
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rcx, %rbx ; X64-NEXT: addq %rcx, %rbx
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %r15 ; X64-NEXT: movq %rax, %r15
; X64-NEXT: addq %rbx, %r15 ; X64-NEXT: addq %rbx, %r15
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rsi, %rcx
; X64-NEXT: addq %rdi, %rcx
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rbp, %r14 ; X64-NEXT: movq %rdi, %r11
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rsi, %rdx ; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r8 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r8 # 8-byte Reload
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r8 # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %r8 # 8-byte Folded Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r10 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload
; X64-NEXT: addq %rax, %r8 ; X64-NEXT: addq %rax, %r8
; X64-NEXT: adcq %rdx, %r10 ; X64-NEXT: adcq %rdx, %r10
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r13 ; X64-NEXT: movq %r14, %rsi
; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r14 # 8-byte Reload
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %r13 ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rcx, %rbx ; X64-NEXT: addq %rcx, %rbx
; X64-NEXT: adcq $0, %rdi
; X64-NEXT: movq %rsi, %rax
; X64-NEXT: movq %rsi, %r9
; X64-NEXT: mulq %r14
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: addq %rbx, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: addq %rdi, %rsi ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: sbbq %rdi, %rdi ; X64-NEXT: mulq %r11
; X64-NEXT: andl $1, %edi
; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %r14
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: addq %rbx, %rax
; X64-NEXT: addq %rsi, %rbx ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %rdi, %rcx ; X64-NEXT: adcq %rsi, %rcx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: sbbq %rbx, %rbx
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: andl $1, %ebx
; X64-NEXT: addq %r11, %rbx ; X64-NEXT: movq %r14, %rax
; X64-NEXT: adcq %r15, %rcx ; X64-NEXT: mulq %r11
; X64-NEXT: movq %rdx, %r11
; X64-NEXT: movq %rax, %rsi
; X64-NEXT: addq %rcx, %rsi
; X64-NEXT: adcq %rbx, %r11
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: addq %r9, %rsi
; X64-NEXT: adcq %r15, %r11
; X64-NEXT: adcq $0, %r8 ; X64-NEXT: adcq $0, %r8
; X64-NEXT: adcq $0, %r10 ; X64-NEXT: adcq $0, %r10
; X64-NEXT: movq %r9, %rsi ; X64-NEXT: movq %rdi, %rbx
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %r9 ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq %rax, %r9
; X64-NEXT: movq %rbp, %r14
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdi, %r13 ; X64-NEXT: movq %rdi, %r15
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %r9, %rbp ; X64-NEXT: addq %rcx, %rbp
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: adcq $0, %rdi
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: mulq %r12 ; X64-NEXT: movq %r12, %r13
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: mulq %r13
; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rbp, %rax ; X64-NEXT: addq %rbp, %rax
; X64-NEXT: movq %rax, %r15 ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq %rdi, %rcx
; X64-NEXT: addq %rdi, %rsi
; X64-NEXT: sbbq %rdi, %rdi ; X64-NEXT: sbbq %rdi, %rdi
; X64-NEXT: andl $1, %edi ; X64-NEXT: andl $1, %edi
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %r12 ; X64-NEXT: mulq %r13
; X64-NEXT: addq %rsi, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rdi, %rdx ; X64-NEXT: adcq %rdi, %rdx
; X64-NEXT: movq (%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbx # 8-byte Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r14 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r14 # 8-byte Reload
; X64-NEXT: addq %r14, %rsi ; X64-NEXT: addq %r14, %rbx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: addq %rax, %rbx
; X64-NEXT: adcq %rdx, %rcx
; X64-NEXT: addq %rsi, %r9
; X64-NEXT: movq %r9, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r11, %rbp
; X64-NEXT: movq %rbp, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rbx
; X64-NEXT: adcq $0, %rcx
; X64-NEXT: addq %r8, %rbx
; X64-NEXT: adcq %r10, %rcx
; X64-NEXT: movl $0, %r12d
; X64-NEXT: adcq $0, %r12
; X64-NEXT: sbbq %r9, %r9
; X64-NEXT: andl $1, %r9d
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbp # 8-byte Folded Reload ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: addq %rax, %rsi ; X64-NEXT: mulq %r15
; X64-NEXT: adcq %rdx, %rbp ; X64-NEXT: movq %rdx, %r8
; X64-NEXT: addq %rbx, %r11 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: movq %r11, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: adcq %rcx, %r15 ; X64-NEXT: movq %r10, %rax
; X64-NEXT: movq %r15, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rdi
; X64-NEXT: addq %r8, %rdi
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: addq %r8, %rsi
; X64-NEXT: adcq %r10, %rbp
; X64-NEXT: movl $0, %r10d
; X64-NEXT: adcq $0, %r10
; X64-NEXT: sbbq %r15, %r15
; X64-NEXT: andl $1, %r15d
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %r13 ; X64-NEXT: mulq %r13
; X64-NEXT: movq %rdx, %r9 ; X64-NEXT: movq %rdx, %r8
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq %rax, %r15
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r8 # 8-byte Reload ; X64-NEXT: addq %rdi, %r15
; X64-NEXT: movq %r8, %rax ; X64-NEXT: adcq %rsi, %r8
; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %r10, %rax
; X64-NEXT: movq %r10, %rbp
; X64-NEXT: mulq %r13 ; X64-NEXT: mulq %r13
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: addq %r8, %rax
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: addq %r9, %rbx ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: movq %r10, %rsi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: addq %r14, %rsi
; X64-NEXT: movq %r12, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r8 # 8-byte Reload
; X64-NEXT: mulq %r12 ; X64-NEXT: movq %r8, %rdi
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: addq %rax, %rsi
; X64-NEXT: addq %rbx, %r9 ; X64-NEXT: adcq %rdx, %rdi
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: addq %rbx, %r11
; X64-NEXT: addq %rdi, %rcx ; X64-NEXT: adcq %rcx, %r15
; X64-NEXT: sbbq %rdi, %rdi ; X64-NEXT: adcq %r12, %rsi
; X64-NEXT: andl $1, %edi ; X64-NEXT: adcq %r9, %rdi
; X64-NEXT: movq %r8, %rax
; X64-NEXT: mulq %r12
; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rdi, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: addq %r14, %rcx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r12 # 8-byte Reload
; X64-NEXT: movq %r12, %r13
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload
; X64-NEXT: addq %rax, %rcx
; X64-NEXT: adcq %rdx, %r13
; X64-NEXT: addq %rsi, %r11
; X64-NEXT: adcq %rbp, %r9
; X64-NEXT: adcq %r10, %rcx
; X64-NEXT: adcq %r15, %r13
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r9 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: addq {{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: movq %r11, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r11, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r9 # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload
; X64-NEXT: movq %r9, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r15, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rsi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: adcq $0, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq $0, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: adcq $0, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq $0, {{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq $0, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: adcq $0, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: adcq $0, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, %r14
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rcx, %r11 ; X64-NEXT: movq %rcx, %r13
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: addq %rdi, %rbp ; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: adcq $0, %rbx
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %r10 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: addq %rbp, %r10 ; X64-NEXT: addq %rcx, %r11
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rbx, %rsi
; X64-NEXT: addq %rbx, %rcx ; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: andl $1, %ecx
; X64-NEXT: andl $1, %esi ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: movq %r8, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdi, %r14 ; X64-NEXT: movq %rdi, %r15
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rsi, %rax
; X64-NEXT: adcq %rsi, %rdx ; X64-NEXT: adcq %rcx, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r9 # 8-byte Reload ; X64-NEXT: movq %r10, %r9
; X64-NEXT: addq {{[0-9]+}}(%rsp), %r9 # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %r9 # 8-byte Folded Reload
; X64-NEXT: movq %r12, %r15 ; X64-NEXT: movq %r8, %r12
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload ; X64-NEXT: adcq (%rsp), %r12 # 8-byte Folded Reload
; X64-NEXT: addq %rax, %r9 ; X64-NEXT: addq %rax, %r9
; X64-NEXT: adcq %rdx, %r15 ; X64-NEXT: adcq %rdx, %r12
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %r11, %rdi ; X64-NEXT: movq %r13, %rbp
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rdx, %r8 ; X64-NEXT: movq %rdx, %r8
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r11 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r13 # 8-byte Reload
; X64-NEXT: movq %r11, %rax ; X64-NEXT: movq %r13, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %r8, %rbp ; X64-NEXT: addq %r8, %rbx
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %rcx, %r8 ; X64-NEXT: movq %rcx, %rbp
; X64-NEXT: mulq %r14 ; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rbp, %rax ; X64-NEXT: addq %rbx, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rsi, %rcx
; X64-NEXT: addq %rbx, %rcx ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: sbbq %rbp, %rbp ; X64-NEXT: andl $1, %esi
; X64-NEXT: andl $1, %ebp ; X64-NEXT: movq %r13, %rax
; X64-NEXT: movq %r11, %rax ; X64-NEXT: mulq %r15
; X64-NEXT: mulq %r14 ; X64-NEXT: movq %rdx, %r8
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rcx, %rbx ; X64-NEXT: addq %rcx, %rbx
; X64-NEXT: adcq %rbp, %rsi ; X64-NEXT: adcq %rsi, %r8
; X64-NEXT: addq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r8 # 8-byte Folded Reload
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: addq %r14, %rbx
; X64-NEXT: adcq %r10, %rsi ; X64-NEXT: adcq %r11, %r8
; X64-NEXT: adcq $0, %r9 ; X64-NEXT: adcq $0, %r9
; X64-NEXT: adcq $0, %r15 ; X64-NEXT: adcq $0, %r12
; X64-NEXT: movq %r8, %rbp ; X64-NEXT: movq %rbp, %rsi
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %r14 ; X64-NEXT: movq %rdx, %r14
; X64-NEXT: movq %rax, %r8 ; X64-NEXT: movq %rax, %r10
; X64-NEXT: movq %r11, %rax ; X64-NEXT: movq %r13, %rax
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %r12 ; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: movq %rax, %rcx ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: addq %r14, %rcx ; X64-NEXT: addq %r14, %rcx
; X64-NEXT: adcq $0, %r12 ; X64-NEXT: adcq $0, %rdi
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: movq 56(%rax), %rdi ; X64-NEXT: movq 56(%rax), %r15
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdi, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: movq %rax, %r10 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: adcq %rdi, %rsi
; X64-NEXT: addq %r12, %rbp
; X64-NEXT: sbbq %rcx, %rcx ; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: andl $1, %ecx ; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %r11, %rax ; X64-NEXT: movq %r13, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %r15
; X64-NEXT: addq %rbp, %rax ; X64-NEXT: addq %rsi, %rax
; X64-NEXT: adcq %rcx, %rdx ; X64-NEXT: adcq %rcx, %rdx
; X64-NEXT: movq (%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r11 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r13 # 8-byte Reload
; X64-NEXT: addq %r11, %rcx ; X64-NEXT: addq %r13, %rdi
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r12 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: adcq %r12, %rdi ; X64-NEXT: adcq %rbp, %rsi
; X64-NEXT: addq %rax, %rcx ; X64-NEXT: addq %rax, %rdi
; X64-NEXT: adcq %rdx, %rdi ; X64-NEXT: adcq %rdx, %rsi
; X64-NEXT: addq %rbx, %r8 ; X64-NEXT: addq %rbx, %r10
; X64-NEXT: movq %r8, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %rsi, %r10
; X64-NEXT: movq %r10, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r10, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %r8, %r11
; X64-NEXT: movq %r11, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: adcq $0, %rdi
; X64-NEXT: addq %r9, %rcx
; X64-NEXT: adcq %r15, %rdi
; X64-NEXT: movl $0, %r8d
; X64-NEXT: adcq $0, %r8
; X64-NEXT: sbbq %r9, %r9
; X64-NEXT: andl $1, %r9d
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rsi, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbx # 8-byte Reload
; X64-NEXT: mulq %rbx
; X64-NEXT: movq %rdx, %r10
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r14 # 8-byte Reload
; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %rbx
; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %r10, %rbp
; X64-NEXT: adcq $0, %rbx
; X64-NEXT: movq %rsi, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: mulq %r10
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %r15
; X64-NEXT: addq %rbp, %r15
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: addq %rbx, %rsi ; X64-NEXT: addq %r9, %rdi
; X64-NEXT: sbbq %rbp, %rbp ; X64-NEXT: adcq %r12, %rsi
; X64-NEXT: andl $1, %ebp ; X64-NEXT: movl $0, %r14d
; X64-NEXT: movq %r14, %rax ; X64-NEXT: adcq $0, %r14
; X64-NEXT: mulq %r10 ; X64-NEXT: sbbq %r10, %r10
; X64-NEXT: addq %rsi, %rax ; X64-NEXT: andl $1, %r10d
; X64-NEXT: adcq %rbp, %rdx ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbx # 8-byte Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r10 # 8-byte Reload ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: addq %r11, %r10 ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r14 # 8-byte Reload ; X64-NEXT: mulq %rcx
; X64-NEXT: adcq %r12, %r14 ; X64-NEXT: movq %rdx, %r8
; X64-NEXT: addq %rax, %r10 ; X64-NEXT: movq %rax, %r12
; X64-NEXT: adcq %rdx, %r14 ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r9 # 8-byte Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq %r9, %rax
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: mulq %rcx
; X64-NEXT: adcq %rdi, %r15 ; X64-NEXT: movq %rdx, %r11
; X64-NEXT: adcq %r8, %r10 ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: adcq %r9, %r14 ; X64-NEXT: addq %r8, %rcx
; X64-NEXT: addq {{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload ; X64-NEXT: adcq $0, %r11
; X64-NEXT: movq %rbx, %rax
; X64-NEXT: movq %r15, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %r8
; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rcx, %rbx
; X64-NEXT: adcq %r11, %r8
; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %r9, %rax
; X64-NEXT: mulq %r15
; X64-NEXT: addq %r8, %rax
; X64-NEXT: adcq %rcx, %rdx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r15 # 8-byte Reload
; X64-NEXT: addq %r13, %r15
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r11 # 8-byte Reload
; X64-NEXT: adcq %rbp, %r11
; X64-NEXT: addq %rax, %r15
; X64-NEXT: adcq %rdx, %r11
; X64-NEXT: addq %rdi, %r12
; X64-NEXT: adcq %rsi, %rbx
; X64-NEXT: adcq %r14, %r15
; X64-NEXT: adcq %r10, %r11
; X64-NEXT: addq {{[0-9]+}}(%rsp), %r12 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r14 # 8-byte Folded Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: addq %rcx, {{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: addq %rcx, {{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: adcq %rcx, {{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: adcq %rcx, {{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: adcq %rcx, {{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: adcq %rcx, {{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq %r13, {{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: adcq $0, %rax ; X64-NEXT: adcq %rcx, {{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq $0, %r12
; X64-NEXT: adcq $0, %rbx
; X64-NEXT: adcq $0, %r15 ; X64-NEXT: adcq $0, %r15
; X64-NEXT: adcq $0, %r10 ; X64-NEXT: adcq $0, %r11
; X64-NEXT: adcq $0, %r14 ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r12 # 8-byte Folded Reload
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload ; X64-NEXT: movq %r12, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: movq %rbx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r15 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r14 # 8-byte Folded Reload
; X64-NEXT: movl $0, %eax ; X64-NEXT: movl $0, %eax
; X64-NEXT: adcq $0, %rax ; X64-NEXT: adcq $0, %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movl $0, %eax ; X64-NEXT: movl $0, %eax
; X64-NEXT: adcq $0, %rax ; X64-NEXT: adcq $0, %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movl $0, %eax ; X64-NEXT: movl $0, %eax
; X64-NEXT: adcq $0, %rax ; X64-NEXT: adcq $0, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: sbbq %rax, %rax ; X64-NEXT: sbbq %rax, %rax
; X64-NEXT: andl $1, %eax ; X64-NEXT: andl $1, %eax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: mulq %rcx ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rcx, %r9
; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %rcx
; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: adcq $0, %rbx
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %r8
; X64-NEXT: movq %rax, %r13 ; X64-NEXT: movq %rax, %r13
; X64-NEXT: addq %rcx, %r13 ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: addq %rbx, %rsi
; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdi, %r11 ; X64-NEXT: movq %rdi, %r14
; X64-NEXT: addq %rsi, %rax ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: adcq %rcx, %rdx ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r12 # 8-byte Reload ; X64-NEXT: addq %r8, %rbp
; X64-NEXT: addq {{[0-9]+}}(%rsp), %r12 # 8-byte Folded Reload ; X64-NEXT: adcq $0, %rbx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r8 # 8-byte Reload ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r8 # 8-byte Folded Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r8 # 8-byte Reload
; X64-NEXT: addq %rax, %r12 ; X64-NEXT: mulq %r8
; X64-NEXT: adcq %rdx, %r8 ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %r12
; X64-NEXT: addq %rbp, %r12
; X64-NEXT: adcq %rbx, %rcx
; X64-NEXT: sbbq %rbp, %rbp
; X64-NEXT: andl $1, %ebp
; X64-NEXT: movq %rsi, %rax
; X64-NEXT: mulq %r8
; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rbp, %rdx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r9 # 8-byte Reload
; X64-NEXT: addq {{[0-9]+}}(%rsp), %r9 # 8-byte Folded Reload
; X64-NEXT: movq (%rsp), %r10 # 8-byte Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload
; X64-NEXT: addq %rax, %r9
; X64-NEXT: adcq %rdx, %r10
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r9 ; X64-NEXT: movq %r14, %rbx
; X64-NEXT: mulq %rbx
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, (%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: mulq %r9 ; X64-NEXT: mulq %rbx
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rcx, %rbx ; X64-NEXT: addq %rcx, %rbp
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rbx
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq %rdi, %r9 ; X64-NEXT: movq %rdi, %r14
; X64-NEXT: mulq %r11 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rbx, %rax ; X64-NEXT: addq %rbp, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rbx, %rcx
; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: sbbq %rdi, %rdi ; X64-NEXT: sbbq %rdi, %rdi
; X64-NEXT: andl $1, %edi ; X64-NEXT: andl $1, %edi
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: mulq %r11 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %r11 ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %rsi ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rcx, %rsi ; X64-NEXT: addq %rcx, %rbp
; X64-NEXT: adcq %rdi, %r11 ; X64-NEXT: adcq %rdi, %rbx
; X64-NEXT: addq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %rbp # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: addq %r13, %rbp
; X64-NEXT: adcq %r13, %r11 ; X64-NEXT: adcq %r12, %rbx
; X64-NEXT: adcq $0, %r12 ; X64-NEXT: adcq $0, %r9
; X64-NEXT: adcq $0, %r8 ; X64-NEXT: movq %r9, %r12
; X64-NEXT: movq %r8, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: adcq $0, %r10
; X64-NEXT: movq %r9, %rdi ; X64-NEXT: movq %r10, %r8
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %r8
; X64-NEXT: movq %rax, %r13
; X64-NEXT: movq %rbp, %rax
; X64-NEXT: movq %rbp, %r9
; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %rcx
; X64-NEXT: addq %r8, %rcx
; X64-NEXT: adcq $0, %rbp
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: movq %rax, %r9
; X64-NEXT: movq %rax, %r8 ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: movq %rsi, %r10
; X64-NEXT: addq %rbp, %rbx
; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %r9, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: addq %rbx, %rax ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: adcq %rcx, %rdx ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: addq %rcx, %rdi
; X64-NEXT: addq {{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %r14, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: mulq %rcx
; X64-NEXT: addq %rax, %rdi ; X64-NEXT: movq %rdx, %r14
; X64-NEXT: addq %rdi, %rax
; X64-NEXT: movq %rax, %rdi
; X64-NEXT: adcq %rsi, %r14
; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %r10, %rax
; X64-NEXT: mulq %rcx
; X64-NEXT: addq %r14, %rax
; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r14 # 8-byte Reload
; X64-NEXT: addq %r14, %rsi
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r13 # 8-byte Reload
; X64-NEXT: adcq %r13, %rcx
; X64-NEXT: addq %rax, %rsi
; X64-NEXT: adcq %rdx, %rcx ; X64-NEXT: adcq %rdx, %rcx
; X64-NEXT: addq %rsi, %r13 ; X64-NEXT: addq %rbp, %r9
; X64-NEXT: adcq %r11, %r8 ; X64-NEXT: movq %r9, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r8, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: adcq %rbx, %rdi
; X64-NEXT: adcq $0, %rdi
; X64-NEXT: adcq $0, %rcx
; X64-NEXT: addq %r12, %rdi
; X64-NEXT: movq %rdi, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: adcq $0, %rcx
; X64-NEXT: movl $0, %r12d ; X64-NEXT: addq %r12, %rsi
; X64-NEXT: adcq $0, %r12 ; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r8, %rcx
; X64-NEXT: movq %rcx, %r12
; X64-NEXT: movl $0, %r10d
; X64-NEXT: adcq $0, %r10
; X64-NEXT: sbbq %r9, %r9 ; X64-NEXT: sbbq %r9, %r9
; X64-NEXT: andl $1, %r9d ; X64-NEXT: andl $1, %r9d
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbx # 8-byte Reload
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r8 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r8 # 8-byte Reload
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r8, %rax
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: addq %rcx, %rbp ; X64-NEXT: addq %rcx, %rdi
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rbp, %rbx ; X64-NEXT: addq %rdi, %rbx
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rsi, %rcx
; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r8, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rbp
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rsi, %rdx ; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: addq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: addq %r14, %rsi
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: adcq %r13, %rcx
; X64-NEXT: addq %rax, %rsi ; X64-NEXT: addq %rax, %rsi
; X64-NEXT: adcq %rdx, %rcx ; X64-NEXT: adcq %rdx, %rcx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r13 # 8-byte Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload
; X64-NEXT: adcq %r12, %rsi ; X64-NEXT: adcq %r12, %rbx
; X64-NEXT: adcq %r10, %rsi
; X64-NEXT: adcq %r9, %rcx ; X64-NEXT: adcq %r9, %rcx
; X64-NEXT: addq {{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: addq %rax, {{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: addq %rax, (%rsp) # 8-byte Folded Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: adcq %rax, {{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq %r15, {{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: adcq %r15, {{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq %r10, %r13 ; X64-NEXT: adcq %r11, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload
; X64-NEXT: movq %r13, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r13, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r14, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: movq %r11, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: movq %rbx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rbx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: movq %rsi, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rsi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r9 # 8-byte Reload
; X64-NEXT: movq 64(%rsi), %r14 ; X64-NEXT: movq 64(%r9), %r11
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r14 ; X64-NEXT: mulq %r11
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r8 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r10, %rax
; X64-NEXT: mulq %r14 ; X64-NEXT: mulq %r11
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rcx, %rbx ; X64-NEXT: addq %rcx, %rbx
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: movq 72(%rsi), %rcx ; X64-NEXT: movq 72(%r9), %rcx
; X64-NEXT: movq %rsi, %r13 ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rcx, %rsi ; X64-NEXT: movq %rcx, %rsi
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %r10 ; X64-NEXT: movq %rax, %r8
; X64-NEXT: addq %rbx, %r10 ; X64-NEXT: addq %rbx, %r8
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rbp, %rcx
; X64-NEXT: addq %rdi, %rcx ; X64-NEXT: sbbq %rbp, %rbp
; X64-NEXT: sbbq %rdi, %rdi ; X64-NEXT: andl $1, %ebp
; X64-NEXT: andl $1, %edi ; X64-NEXT: movq %r10, %rax
; X64-NEXT: movq %r8, %rax
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rsi, %r8 ; X64-NEXT: movq %rsi, %r10
; X64-NEXT: movq %r10, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: addq %rcx, %rbp ; X64-NEXT: addq %rcx, %rdi
; X64-NEXT: adcq %rdi, %rsi ; X64-NEXT: adcq %rbp, %rsi
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: xorl %ecx, %ecx ; X64-NEXT: xorl %ecx, %ecx
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: movq %rdx, %r11 ; X64-NEXT: movq %rdx, %r14
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r15 # 8-byte Reload
; X64-NEXT: addq %rbx, %r15
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r12 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r12 # 8-byte Reload
; X64-NEXT: adcq %r11, %r12 ; X64-NEXT: addq %rbx, %r12
; X64-NEXT: addq %rbp, %r15 ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r15 # 8-byte Reload
; X64-NEXT: adcq %rsi, %r12 ; X64-NEXT: adcq %r14, %r15
; X64-NEXT: addq %rdi, %r12
; X64-NEXT: adcq %rsi, %r15
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %r14, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r11, %rsi
; X64-NEXT: mulq %r14 ; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, %r9 ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %r11
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %r14 ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: addq %r9, %rbp ; X64-NEXT: addq %r11, %rdi
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %rcx, %r14 ; X64-NEXT: movq %rcx, %r11
; X64-NEXT: movq %r8, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: mulq %r10
; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rbp, %rax ; X64-NEXT: addq %rdi, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rsi, %rcx
; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: movq %rdi, %r9 ; X64-NEXT: movq %rbp, %rdi
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r10
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rsi, %rdx ; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r13 # 8-byte Reload
; X64-NEXT: adcq %r13, %r14
; X64-NEXT: addq %rax, %rbx ; X64-NEXT: addq %rax, %rbx
; X64-NEXT: adcq %rdx, %r11 ; X64-NEXT: adcq %rdx, %r14
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: adcq %r10, %r11 ; X64-NEXT: adcq %r8, %r14
; X64-NEXT: adcq $0, %r15
; X64-NEXT: adcq $0, %r12 ; X64-NEXT: adcq $0, %r12
; X64-NEXT: movq 80(%r13), %rbp ; X64-NEXT: adcq $0, %r15
; X64-NEXT: movq %r14, %rsi ; X64-NEXT: movq %r9, %rbp
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq 80(%rbp), %r8
; X64-NEXT: mulq %rbp ; X64-NEXT: movq %r11, %rax
; X64-NEXT: movq %rdx, %r8 ; X64-NEXT: movq %r11, %r9
; X64-NEXT: movq %rax, %r14 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %r9, %rax
; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rdx, %r10 ; X64-NEXT: movq %rdx, %r10
; X64-NEXT: movq %rax, %r11
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rcx ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: addq %r8, %rcx ; X64-NEXT: addq %r10, %rcx
; X64-NEXT: adcq $0, %r10 ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq 88(%r13), %r13 ; X64-NEXT: movq 88(%rbp), %r10
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %r9, %rax
; X64-NEXT: mulq %r13 ; X64-NEXT: mulq %r10
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %r8 ; X64-NEXT: movq %rax, %r9
; X64-NEXT: addq %rcx, %r8 ; X64-NEXT: addq %rcx, %r9
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: adcq %rsi, %rbp
; X64-NEXT: addq %r10, %rdi
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %r9, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r13 ; X64-NEXT: mulq %r10
; X64-NEXT: movq %rdx, %r10 ; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: movq %rax, %rcx ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: addq %rdi, %rcx ; X64-NEXT: addq %rbp, %rcx
; X64-NEXT: adcq %rsi, %r10 ; X64-NEXT: adcq %rsi, %rdi
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %r8, %rax
; X64-NEXT: xorl %edx, %edx ; X64-NEXT: xorl %edx, %edx
; X64-NEXT: mulq %rdx ; X64-NEXT: mulq %rdx
; X64-NEXT: movq %rdx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: addq %rax, %rsi
; X64-NEXT: addq %rdi, %rsi ; X64-NEXT: movq %r13, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: adcq %rdx, %rax ; X64-NEXT: adcq %rdx, %rax
; X64-NEXT: movq %rdx, %r13
; X64-NEXT: addq %rcx, %rsi ; X64-NEXT: addq %rcx, %rsi
; X64-NEXT: adcq %r10, %rax ; X64-NEXT: adcq %rdi, %rax
; X64-NEXT: addq %rbx, %r14 ; X64-NEXT: addq %rbx, %r11
; X64-NEXT: movq %r14, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r11, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r11, %r8 ; X64-NEXT: adcq %r14, %r9
; X64-NEXT: movq %r8, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r9, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: adcq $0, %rax ; X64-NEXT: adcq $0, %rax
; X64-NEXT: addq %r15, %rsi ; X64-NEXT: addq %r12, %rsi
; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rsi, %r14
; X64-NEXT: adcq %r12, %rax ; X64-NEXT: adcq %r15, %rax
; X64-NEXT: movq %rax, %r10 ; X64-NEXT: movq %rax, %r9
; X64-NEXT: movl $0, %r15d ; X64-NEXT: movl $0, %r12d
; X64-NEXT: adcq $0, %r15 ; X64-NEXT: adcq $0, %r12
; X64-NEXT: sbbq %r12, %r12 ; X64-NEXT: sbbq %r11, %r11
; X64-NEXT: andl $1, %r12d ; X64-NEXT: andl $1, %r11d
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %r8 ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %r14 ; X64-NEXT: movq %rax, %r15
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r11 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: movq %r11, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %r8, %rbx ; X64-NEXT: addq %rcx, %rbx
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r13 ; X64-NEXT: mulq %r10
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rbx, %rax ; X64-NEXT: addq %rbx, %rax
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rsi, %rcx
; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %r11, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %r13 ; X64-NEXT: mulq %r10
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rsi, %rdx ; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: addq %rdi, %rsi ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: adcq %r13, %rcx
; X64-NEXT: addq %rax, %rsi ; X64-NEXT: addq %rax, %rsi
; X64-NEXT: adcq %rdx, %rcx ; X64-NEXT: adcq %rdx, %rcx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r14 # 8-byte Folded Reload ; X64-NEXT: addq %r14, %r15
; X64-NEXT: movq %r14, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r15, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r10, %rbx ; X64-NEXT: adcq %r9, %rdi
; X64-NEXT: movq %rbx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r15, %rsi ; X64-NEXT: adcq %r12, %rsi
; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r12, %rcx ; X64-NEXT: adcq %r11, %rcx
; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: imulq %rax, %r13 ; X64-NEXT: imulq %rax, %r10
; X64-NEXT: movq %rax, %r8 ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r9
; X64-NEXT: addq %r13, %rdx ; X64-NEXT: addq %r10, %rdx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: imulq %rdi, %rbp ; X64-NEXT: imulq %r10, %r8
; X64-NEXT: addq %rdx, %rbp ; X64-NEXT: addq %rdx, %r8
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: movq %rax, %rsi ; X64-NEXT: movq %rax, %rsi
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r12 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbx # 8-byte Reload
; X64-NEXT: imulq %r12, %rsi ; X64-NEXT: imulq %rbx, %rsi
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rax, %r10 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: addq %rsi, %rdx ; X64-NEXT: addq %rsi, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: imulq %rcx, %rax ; X64-NEXT: imulq %rbp, %rax
; X64-NEXT: addq %rdx, %rax ; X64-NEXT: addq %rdx, %rax
; X64-NEXT: addq %r9, %r10 ; X64-NEXT: addq %r9, %r11
; X64-NEXT: adcq %rbp, %rax ; X64-NEXT: adcq %r8, %rax
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r14
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: movq %rcx, %rbp ; X64-NEXT: mulq %rdi
; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %r12, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: movq %rbx, %r8
; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rcx, %rbx ; X64-NEXT: addq %rcx, %rbx
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: movq %r10, %rbp
; X64-NEXT: movq %rdx, %rbp ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rax, %r14 ; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: addq %rbx, %r14 ; X64-NEXT: movq %rax, %r15
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: addq %rbx, %r15
; X64-NEXT: addq %rsi, %rbp ; X64-NEXT: adcq %rsi, %rdi
; X64-NEXT: sbbq %rcx, %rcx ; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: andl $1, %ecx ; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %r12, %rax ; X64-NEXT: movq %r8, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rdx, %r12 ; X64-NEXT: movq %rdx, %r12
; X64-NEXT: movq %rax, %r8 ; X64-NEXT: movq %rax, %r9
; X64-NEXT: addq %rbp, %r8 ; X64-NEXT: addq %rdi, %r9
; X64-NEXT: adcq %rcx, %r12 ; X64-NEXT: adcq %rcx, %r12
; X64-NEXT: addq %r10, %r8 ; X64-NEXT: addq %r11, %r9
; X64-NEXT: adcq %r9, %r12 ; X64-NEXT: adcq %r14, %r12
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdx # 8-byte Reload
; X64-NEXT: movq 120(%rdx), %rcx ; X64-NEXT: movq 120(%rdx), %rcx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r9 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: imulq %r9, %rcx ; X64-NEXT: imulq %r10, %rcx
; X64-NEXT: movq 112(%rdx), %rsi ; X64-NEXT: movq 112(%rdx), %rsi
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %r9, %rax ; X64-NEXT: movq %r10, %rax
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rax, %r15 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: addq %rcx, %rdx ; X64-NEXT: addq %rcx, %rdx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r10 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r8 # 8-byte Reload
; X64-NEXT: imulq %r10, %rsi ; X64-NEXT: imulq %r8, %rsi
; X64-NEXT: addq %rdx, %rsi ; X64-NEXT: addq %rdx, %rsi
; X64-NEXT: movq 96(%rdi), %rbp ; X64-NEXT: movq 96(%rbp), %rdi
; X64-NEXT: movq 104(%rdi), %rbx ; X64-NEXT: movq 104(%rbp), %rbx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: movq %rax, %rcx ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: imulq %rbx, %rcx ; X64-NEXT: imulq %rbx, %rcx
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rax, %r13 ; X64-NEXT: movq %rax, %r13
; X64-NEXT: addq %rcx, %rdx ; X64-NEXT: addq %rcx, %rdx
; X64-NEXT: imulq %rbp, %r11 ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: addq %rdx, %r11 ; X64-NEXT: imulq %rdi, %rax
; X64-NEXT: addq %r15, %r13 ; X64-NEXT: addq %rdx, %rax
; X64-NEXT: adcq %rsi, %r11 ; X64-NEXT: addq %r11, %r13
; X64-NEXT: movq %r11, %r15 ; X64-NEXT: adcq %rsi, %rax
; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %r9
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r9
; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: movq %rax, %rcx
; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: adcq $0, %rdi
; X64-NEXT: movq %rbp, %rax
; X64-NEXT: mulq %r10 ; X64-NEXT: mulq %r10
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %r14
; X64-NEXT: addq %rcx, %rbp
; X64-NEXT: adcq $0, %rsi
; X64-NEXT: addq %rdi, %rsi
; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: mulq %r10 ; X64-NEXT: mulq %r10
; X64-NEXT: addq %rsi, %rax ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: adcq %rcx, %rdx ; X64-NEXT: movq %rax, %rsi
; X64-NEXT: addq %rcx, %rsi
; X64-NEXT: adcq $0, %rbp
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %rdi
; X64-NEXT: addq %rsi, %rdi
; X64-NEXT: adcq %rbp, %rcx
; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %rbx, %rax
; X64-NEXT: mulq %r8
; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: addq %r13, %rax ; X64-NEXT: addq %r13, %rax
; X64-NEXT: adcq %r15, %rdx ; X64-NEXT: adcq %r11, %rdx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r14 # 8-byte Folded Reload
; X64-NEXT: adcq %r14, %rbp ; X64-NEXT: adcq %r15, %rdi
; X64-NEXT: adcq %r8, %rax ; X64-NEXT: adcq %r9, %rax
; X64-NEXT: adcq %r12, %rdx ; X64-NEXT: adcq %r12, %rdx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r14 # 8-byte Folded Reload
; X64-NEXT: movq %r11, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r14, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbp # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: movq %rbp, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload
; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq 80(%rsi), %r9 ; X64-NEXT: movq 80(%rsi), %rcx
; X64-NEXT: movq %r9, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r8 # 8-byte Reload
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %r9
; X64-NEXT: movq 88(%rsi), %r8 ; X64-NEXT: movq 88(%rsi), %r10
; X64-NEXT: movq %rsi, %r11 ; X64-NEXT: movq %rsi, %r12
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r10, %rax
; X64-NEXT: movq %r8, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r10, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdi, %rbx ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: addq %r9, %rbx
; X64-NEXT: addq %rcx, %rdi ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %r9, %rax ; X64-NEXT: movq %rcx, %r9
; X64-NEXT: movq %r9, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r9, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r15 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r15 # 8-byte Reload
; X64-NEXT: mulq %r15 ; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %rbp ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %r14 ; X64-NEXT: addq %rbx, %rax
; X64-NEXT: addq %rdi, %r14 ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: adcq %rbp, %rsi
; X64-NEXT: addq %rsi, %rbp
; X64-NEXT: sbbq %rdi, %rdi ; X64-NEXT: sbbq %rdi, %rdi
; X64-NEXT: andl $1, %edi ; X64-NEXT: andl $1, %edi
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r10, %rax
; X64-NEXT: mulq %r15 ; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %rcx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rbp, %rcx ; X64-NEXT: addq %rsi, %rbx
; X64-NEXT: adcq %rdi, %rsi ; X64-NEXT: adcq %rdi, %rbp
; X64-NEXT: movq %r9, %rax ; X64-NEXT: movq %r9, %rax
; X64-NEXT: xorl %r13d, %r13d ; X64-NEXT: xorl %ecx, %ecx
; X64-NEXT: mulq %r13 ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, %r11
; X64-NEXT: movq %r11, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rax, %r10
; X64-NEXT: movq %r10, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r9 # 8-byte Reload
; X64-NEXT: addq %r9, %r10
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r13 # 8-byte Reload
; X64-NEXT: adcq %r13, %r11
; X64-NEXT: addq %rbx, %r10
; X64-NEXT: adcq %rbp, %r11
; X64-NEXT: movq %r12, %rcx
; X64-NEXT: movq 64(%rcx), %rdi
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r8
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq 72(%rcx), %r14
; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rsi, %rbx
; X64-NEXT: adcq $0, %rbp
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: addq %rbx, %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rax, %r12 ; X64-NEXT: adcq %rbp, %rsi
; X64-NEXT: movq (%rsp), %r10 # 8-byte Reload ; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: addq %r10, %r12 ; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rsi, %rbp
; X64-NEXT: adcq %rcx, %rbx
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: xorl %ecx, %ecx
; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %r8 ; X64-NEXT: movq %rdx, %r8
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r9 # 8-byte Reload ; X64-NEXT: movq %rax, %r15
; X64-NEXT: adcq %r9, %r8 ; X64-NEXT: addq %r15, %r9
; X64-NEXT: addq %rcx, %r12 ; X64-NEXT: movq %r13, %rax
; X64-NEXT: adcq %rsi, %r8 ; X64-NEXT: adcq %r8, %rax
; X64-NEXT: movq %r11, %rsi ; X64-NEXT: addq %rbp, %r9
; X64-NEXT: movq 64(%rsi), %r11 ; X64-NEXT: adcq %rbx, %rax
; X64-NEXT: movq %r11, %rax ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r9 # 8-byte Folded Reload
; X64-NEXT: movq %rbx, %rdi ; X64-NEXT: movq %r9, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rdi ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, %r13
; X64-NEXT: adcq $0, %r10
; X64-NEXT: adcq $0, %r11
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq 72(%rsi), %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: movq %r14, %r12
; X64-NEXT: movq %r12, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rsi, %r14
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rcx, %rbp ; X64-NEXT: addq %rcx, %rbp
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %r11, %rax
; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rbp, %rax
; X64-NEXT: movq %rax, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rcx
; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: sbbq %rdi, %rdi
; X64-NEXT: andl $1, %edi
; X64-NEXT: movq %rbx, %rax
; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rcx, %rbp
; X64-NEXT: adcq %rdi, %rsi
; X64-NEXT: movq %r11, %rdi
; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r13 ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rdx, %r11
; X64-NEXT: movq %rax, %r13
; X64-NEXT: addq %r13, %r10
; X64-NEXT: adcq %r11, %r9
; X64-NEXT: addq %rbp, %r10
; X64-NEXT: adcq %rsi, %r9
; X64-NEXT: addq {{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload
; X64-NEXT: movq %r10, (%rsp) # 8-byte Spill
; X64-NEXT: adcq %r14, %r9
; X64-NEXT: movq %r9, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %r12
; X64-NEXT: adcq $0, %r8
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %r9 ; X64-NEXT: movq %rdx, %r9
; X64-NEXT: movq %rax, %r15
; X64-NEXT: movq %rbx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rbx, %rax
; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %rsi
; X64-NEXT: addq %r9, %rsi
; X64-NEXT: adcq $0, %rbp
; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: mulq %r10
; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: addq %rsi, %rdi ; X64-NEXT: addq %rbp, %rdi
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rsi, %r9
; X64-NEXT: addq %rbp, %rcx
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %r12, %rax
; X64-NEXT: mulq %r10 ; X64-NEXT: mulq %rcx
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: movq %rcx, %rbp
; X64-NEXT: addq %r9, %rax
; X64-NEXT: adcq %rsi, %rdx ; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r13 # 8-byte Folded Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r12 # 8-byte Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r14 # 8-byte Reload ; X64-NEXT: addq %r12, %r15
; X64-NEXT: adcq %r14, %r11 ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r8 # 8-byte Folded Reload
; X64-NEXT: addq %rax, %r13 ; X64-NEXT: addq %rax, %r15
; X64-NEXT: adcq %rdx, %r11 ; X64-NEXT: adcq %rdx, %r8
; X64-NEXT: addq (%rsp), %r15 # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: movq %r15, (%rsp) # 8-byte Spill ; X64-NEXT: movq %rbx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload ; X64-NEXT: adcq %r13, %rdi
; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdi, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %r13 ; X64-NEXT: adcq $0, %r15
; X64-NEXT: adcq $0, %r11
; X64-NEXT: addq %r12, %r13
; X64-NEXT: adcq %r8, %r11
; X64-NEXT: movl $0, %r8d
; X64-NEXT: adcq $0, %r8 ; X64-NEXT: adcq $0, %r8
; X64-NEXT: sbbq %r9, %r9 ; X64-NEXT: addq %r10, %r15
; X64-NEXT: andl $1, %r9d ; X64-NEXT: adcq %r11, %r8
; X64-NEXT: movl $0, %r9d
; X64-NEXT: adcq $0, %r9
; X64-NEXT: sbbq %r13, %r13
; X64-NEXT: andl $1, %r13d
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r15 # 8-byte Reload ; X64-NEXT: movq %r14, %rsi
; X64-NEXT: mulq %r15 ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %r12 ; X64-NEXT: movq %rdx, %r14
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: movq %rax, %r10
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r15 ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rsi, %r11
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %r12, %rbp ; X64-NEXT: addq %r14, %rbx
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %r10 ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rbp, %rax ; X64-NEXT: addq %rbx, %rax
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rsi, %rcx
; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r10 ; X64-NEXT: movq %rdi, %r14
; X64-NEXT: mulq %rbp
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rsi, %rdx ; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: addq %r12, %rsi
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: adcq %r14, %rcx ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: addq %rax, %rsi ; X64-NEXT: addq %rax, %rsi
; X64-NEXT: adcq %rdx, %rcx ; X64-NEXT: adcq %rdx, %rcx
; X64-NEXT: addq %r13, %rdi ; X64-NEXT: addq %r15, %r10
; X64-NEXT: movq %rdi, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r10, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r11, %rbp ; X64-NEXT: adcq %r8, %rbx
; X64-NEXT: movq %rbp, {{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rbx, {{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r8, %rsi ; X64-NEXT: adcq %r9, %rsi
; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r9, %rcx ; X64-NEXT: adcq %r13, %rcx
; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq 96(%rbp), %rcx ; X64-NEXT: movq 96(%rsi), %rcx
; X64-NEXT: imulq %rcx, %r10 ; X64-NEXT: imulq %rcx, %rbp
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %r15 ; X64-NEXT: movq %r11, %rdi
; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r9
; X64-NEXT: addq %r10, %rdx ; X64-NEXT: addq %rbp, %rdx
; X64-NEXT: movq 104(%rbp), %r8 ; X64-NEXT: movq 104(%rsi), %r8
; X64-NEXT: imulq %r8, %r15 ; X64-NEXT: imulq %r8, %rdi
; X64-NEXT: addq %rdx, %r15 ; X64-NEXT: addq %rdx, %rdi
; X64-NEXT: movq 112(%rbp), %rax ; X64-NEXT: movq %rdi, %r10
; X64-NEXT: movq %rbp, %rdi ; X64-NEXT: movq 112(%rsi), %rax
; X64-NEXT: movq %rax, %rsi ; X64-NEXT: movq %rsi, %rbp
; X64-NEXT: movq %rax, %rdi
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbx # 8-byte Reload
; X64-NEXT: imulq %rbx, %rsi ; X64-NEXT: imulq %rbx, %rdi
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rax, %r13 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: addq %rsi, %rdx ; X64-NEXT: addq %rdi, %rdx
; X64-NEXT: movq 120(%rdi), %rdi ; X64-NEXT: movq 120(%rbp), %rdi
; X64-NEXT: imulq %rbp, %rdi ; X64-NEXT: imulq %rsi, %rdi
; X64-NEXT: addq %rdx, %rdi ; X64-NEXT: addq %rdx, %rdi
; X64-NEXT: addq %r9, %r13 ; X64-NEXT: addq %r9, %r11
; X64-NEXT: adcq %r15, %rdi ; X64-NEXT: adcq %r10, %rdi
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: movq %rbp, %r9 ; X64-NEXT: movq %rsi, %r10
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %rbp ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: movq %rbx, %r9
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %rsi ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rbp, %rsi ; X64-NEXT: addq %rsi, %rbx
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq $0, %rcx
; X64-NEXT: movq %r9, %rax ; X64-NEXT: movq %r10, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rbp ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %r12 ; X64-NEXT: movq %rax, %r15
; X64-NEXT: addq %rsi, %r12 ; X64-NEXT: addq %rbx, %r15
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: adcq %rcx, %rsi
; X64-NEXT: addq %rcx, %rbp
; X64-NEXT: sbbq %rcx, %rcx ; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: andl $1, %ecx ; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %r9, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %r8 ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r8
; X64-NEXT: addq %rbp, %r9 ; X64-NEXT: addq %rsi, %r8
; X64-NEXT: adcq %rcx, %r8 ; X64-NEXT: adcq %rcx, %rbx
; X64-NEXT: addq %r13, %r9 ; X64-NEXT: addq %r11, %r8
; X64-NEXT: adcq %rdi, %r8 ; X64-NEXT: adcq %rdi, %rbx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: imulq %rbx, %rsi ; X64-NEXT: imulq %rax, %rsi
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rax, %r9
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rax, %r10 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: addq %rsi, %rdx ; X64-NEXT: addq %rsi, %rdx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r11 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %r12 # 8-byte Reload
; X64-NEXT: imulq %r11, %rcx ; X64-NEXT: imulq %r12, %rcx
; X64-NEXT: addq %rdx, %rcx ; X64-NEXT: addq %rdx, %rcx
; X64-NEXT: movq %rcx, %rsi ; X64-NEXT: movq %rcx, %rbp
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: movq %rax, %rcx ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %r14 # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: imulq %r14, %rcx ; X64-NEXT: imulq %rsi, %rcx
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rax, %r13 ; X64-NEXT: movq %rax, %r10
; X64-NEXT: addq %rcx, %rdx ; X64-NEXT: addq %rcx, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq %r14, %r13
; X64-NEXT: imulq %rbp, %rax ; X64-NEXT: imulq %rdi, %r13
; X64-NEXT: addq %rdx, %rax ; X64-NEXT: addq %rdx, %r13
; X64-NEXT: addq %r10, %r13 ; X64-NEXT: addq %r11, %r10
; X64-NEXT: adcq %rsi, %rax ; X64-NEXT: adcq %rbp, %r13
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rdi, %r11
; X64-NEXT: movq %rbp, %r10 ; X64-NEXT: mulq %r9
; X64-NEXT: mulq %rbx ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %rsi, %r14
; X64-NEXT: mulq %rbx ; X64-NEXT: mulq %r9
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %r9
; X64-NEXT: movq %rax, %rcx ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: addq %rsi, %rcx ; X64-NEXT: addq %rbp, %rcx
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: adcq $0, %r9
; X64-NEXT: movq %r10, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: mulq %r11 ; X64-NEXT: movq %r12, %rbp
; X64-NEXT: movq %rdx, %r15 ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rax, %r10 ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: addq %rcx, %r10 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: adcq $0, %r15 ; X64-NEXT: addq %rcx, %r11
; X64-NEXT: addq %rdi, %r15 ; X64-NEXT: adcq %r9, %rsi
; X64-NEXT: sbbq %rcx, %rcx ; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: andl $1, %ecx ; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %r11 ; X64-NEXT: mulq %rbp
; X64-NEXT: addq %r15, %rax ; X64-NEXT: addq %rsi, %rax
; X64-NEXT: adcq %rcx, %rdx ; X64-NEXT: adcq %rcx, %rdx
; X64-NEXT: addq %r13, %rax ; X64-NEXT: addq %r10, %rax
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload ; X64-NEXT: adcq %r13, %rdx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rbp # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: adcq %r12, %r10 ; X64-NEXT: adcq %r15, %r11
; X64-NEXT: adcq %r9, %rax ; X64-NEXT: adcq %r8, %rax
; X64-NEXT: adcq %r8, %rdx ; X64-NEXT: adcq %rbx, %rdx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rbp # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: addq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: addq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: movq (%rsp), %rbx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbx # 8-byte Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rbp # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbp # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload
; X64-NEXT: addq {{[0-9]+}}(%rsp), %rcx # 8-byte Folded Reload ; X64-NEXT: addq (%rsp), %rcx # 8-byte Folded Reload
; X64-NEXT: movq %rcx, %r8 ; X64-NEXT: movq %rcx, %r8
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: movq %rdi, %r9 ; X64-NEXT: movq %rsi, %r9
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rbx # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbp # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rbp # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %r11 # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload
; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload ; X64-NEXT: adcq {{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rdi, (%rcx) ; X64-NEXT: movq %rsi, (%rcx)
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rdi, 8(%rcx) ; X64-NEXT: movq %rsi, 8(%rcx)
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rdi, 16(%rcx) ; X64-NEXT: movq %rsi, 16(%rcx)
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rdi, 24(%rcx) ; X64-NEXT: movq %rsi, 24(%rcx)
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rdi, 32(%rcx) ; X64-NEXT: movq %rsi, 32(%rcx)
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rdi, 40(%rcx) ; X64-NEXT: movq %rsi, 40(%rcx)
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rdi, 48(%rcx) ; X64-NEXT: movq %rsi, 48(%rcx)
; X64-NEXT: movq {{[0-9]+}}(%rsp), %rdi # 8-byte Reload ; X64-NEXT: movq {{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq %rdi, 56(%rcx) ; X64-NEXT: movq %rsi, 56(%rcx)
; X64-NEXT: movq %r8, 64(%rcx) ; X64-NEXT: movq %r8, 64(%rcx)
; X64-NEXT: movq %r9, 72(%rcx) ; X64-NEXT: movq %r9, 72(%rcx)
; X64-NEXT: movq %rbx, 80(%rcx) ; X64-NEXT: movq %rbx, 80(%rcx)
; X64-NEXT: movq %rsi, 88(%rcx) ; X64-NEXT: movq %rbp, 88(%rcx)
; X64-NEXT: movq %rbp, 96(%rcx) ; X64-NEXT: movq %rdi, 96(%rcx)
; X64-NEXT: movq %r10, 104(%rcx) ; X64-NEXT: movq %r11, 104(%rcx)
; X64-NEXT: movq %rax, 112(%rcx) ; X64-NEXT: movq %rax, 112(%rcx)
; X64-NEXT: movq %rdx, 120(%rcx) ; X64-NEXT: movq %rdx, 120(%rcx)
; X64-NEXT: addq $360, %rsp # imm = 0x168 ; X64-NEXT: addq $352, %rsp # imm = 0x160
; X64-NEXT: popq %rbx ; X64-NEXT: popq %rbx
; X64-NEXT: popq %r12 ; X64-NEXT: popq %r12
; X64-NEXT: popq %r13 ; X64-NEXT: popq %r13
; X64-NEXT: popq %r14 ; X64-NEXT: popq %r14
; X64-NEXT: popq %r15 ; X64-NEXT: popq %r15
; X64-NEXT: popq %rbp ; X64-NEXT: popq %rbp
; X64-NEXT: retq ; X64-NEXT: retq
%av = load i1024, i1024* %a %av = load i1024, i1024* %a
%bv = load i1024, i1024* %b %bv = load i1024, i1024* %b
%r = mul i1024 %av, %bv %r = mul i1024 %av, %bv
store i1024 %r, i1024* %out store i1024 %r, i1024* %out
ret void ret void
} }

test/CodeGen/X86/mul-i256.ll

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Lines
; X64-NEXT: .Lcfi4: ; X64-NEXT: .Lcfi4:
; X64-NEXT: .cfi_offset %rbx, -40 ; X64-NEXT: .cfi_offset %rbx, -40
; X64-NEXT: .Lcfi5: ; X64-NEXT: .Lcfi5:
; X64-NEXT: .cfi_offset %r12, -32 ; X64-NEXT: .cfi_offset %r12, -32
; X64-NEXT: .Lcfi6: ; X64-NEXT: .Lcfi6:
; X64-NEXT: .cfi_offset %r14, -24 ; X64-NEXT: .cfi_offset %r14, -24
; X64-NEXT: .Lcfi7: ; X64-NEXT: .Lcfi7:
; X64-NEXT: .cfi_offset %r15, -16 ; X64-NEXT: .cfi_offset %r15, -16
; X64-NEXT: movq %rdx, %r10 ; X64-NEXT: movq %rdx, %r9
; X64-NEXT: movq (%rdi), %r14 ; X64-NEXT: movq (%rdi), %r14
; X64-NEXT: movq 8(%rdi), %r8 ; X64-NEXT: movq 8(%rdi), %r8
; X64-NEXT: movq 16(%rdi), %rcx ; X64-NEXT: movq 16(%rdi), %rcx
; X64-NEXT: movq 16(%rsi), %rbx ; X64-NEXT: movq 16(%rsi), %rbx
; X64-NEXT: movq (%rsi), %r12 ; X64-NEXT: movq (%rsi), %r12
; X64-NEXT: movq 8(%rsi), %r15 ; X64-NEXT: movq 8(%rsi), %r15
; X64-NEXT: movq 24(%rdi), %rdi ; X64-NEXT: movq 24(%rdi), %rdi
; X64-NEXT: imulq %r12, %rdi ; X64-NEXT: imulq %r12, %rdi
; X64-NEXT: movq %r12, %rax ; X64-NEXT: movq %r12, %rax
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r10
; X64-NEXT: addq %rdi, %rdx ; X64-NEXT: addq %rdi, %rdx
; X64-NEXT: imulq %r15, %rcx ; X64-NEXT: imulq %r15, %rcx
; X64-NEXT: addq %rdx, %rcx ; X64-NEXT: addq %rdx, %rcx
; X64-NEXT: movq %rbx, %rdi ; X64-NEXT: movq %rbx, %rdi
; X64-NEXT: imulq %r8, %rdi ; X64-NEXT: imulq %r8, %rdi
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: mulq %r14 ; X64-NEXT: mulq %r14
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: addq %rdi, %rdx ; X64-NEXT: addq %rdi, %rdx
; X64-NEXT: movq 24(%rsi), %rbx ; X64-NEXT: movq 24(%rsi), %rbx
; X64-NEXT: imulq %r14, %rbx ; X64-NEXT: imulq %r14, %rbx
; X64-NEXT: addq %rdx, %rbx ; X64-NEXT: addq %rdx, %rbx
; X64-NEXT: addq %r9, %r11 ; X64-NEXT: addq %r10, %r11
; X64-NEXT: adcq %rcx, %rbx ; X64-NEXT: adcq %rcx, %rbx
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %r12 ; X64-NEXT: mulq %r12
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r10
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r8, %rax
; X64-NEXT: mulq %r12 ; X64-NEXT: mulq %r12
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: addq %rsi, %rdi ; X64-NEXT: addq %rsi, %rdi
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq $0, %rcx
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %r15 ; X64-NEXT: mulq %r15
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %r14 ; X64-NEXT: movq %rax, %r14
; X64-NEXT: addq %rdi, %r14 ; X64-NEXT: addq %rdi, %r14
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq %rcx, %rsi
; X64-NEXT: addq %rcx, %rsi
; X64-NEXT: sbbq %rcx, %rcx ; X64-NEXT: sbbq %rcx, %rcx
; X64-NEXT: andl $1, %ecx ; X64-NEXT: andl $1, %ecx
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r8, %rax
; X64-NEXT: mulq %r15 ; X64-NEXT: mulq %r15
; X64-NEXT: addq %rsi, %rax ; X64-NEXT: addq %rsi, %rax
; X64-NEXT: adcq %rcx, %rdx ; X64-NEXT: adcq %rcx, %rdx
; X64-NEXT: addq %r11, %rax ; X64-NEXT: addq %r11, %rax
; X64-NEXT: adcq %rbx, %rdx ; X64-NEXT: adcq %rbx, %rdx
; X64-NEXT: movq %r9, (%r10) ; X64-NEXT: movq %r10, (%r9)
; X64-NEXT: movq %r14, 8(%r10) ; X64-NEXT: movq %r14, 8(%r9)
; X64-NEXT: movq %rax, 16(%r10) ; X64-NEXT: movq %rax, 16(%r9)
; X64-NEXT: movq %rdx, 24(%r10) ; X64-NEXT: movq %rdx, 24(%r9)
; X64-NEXT: popq %rbx ; X64-NEXT: popq %rbx
; X64-NEXT: popq %r12 ; X64-NEXT: popq %r12
; X64-NEXT: popq %r14 ; X64-NEXT: popq %r14
; X64-NEXT: popq %r15 ; X64-NEXT: popq %r15
; X64-NEXT: retq ; X64-NEXT: retq
entry: entry:
%av = load i256, i256* %a %av = load i256, i256* %a
%bv = load i256, i256* %b %bv = load i256, i256* %b
%r = mul i256 %av, %bv %r = mul i256 %av, %bv
store i256 %r, i256* %out store i256 %r, i256* %out
ret void ret void
} }
attributes #0 = { norecurse nounwind uwtable "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" } attributes #0 = { norecurse nounwind uwtable "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" }

test/CodeGen/X86/mul-i512.ll

Show First 20 Lines • Show All 905 Lines • ▼ Show 20 Lines
; X64-NEXT: pushq %rbp ; X64-NEXT: pushq %rbp
; X64-NEXT: pushq %r15 ; X64-NEXT: pushq %r15
; X64-NEXT: pushq %r14 ; X64-NEXT: pushq %r14
; X64-NEXT: pushq %r13 ; X64-NEXT: pushq %r13
; X64-NEXT: pushq %r12 ; X64-NEXT: pushq %r12
; X64-NEXT: pushq %rbx ; X64-NEXT: pushq %rbx
; X64-NEXT: pushq %rax ; X64-NEXT: pushq %rax
; X64-NEXT: movq %rdx, (%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, (%rsp) # 8-byte Spill
; X64-NEXT: movq 24(%rdi), %rbp ; X64-NEXT: movq 24(%rdi), %r11
; X64-NEXT: movq 16(%rdi), %r11 ; X64-NEXT: movq 16(%rdi), %r14
; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq (%rsi), %rdx ; X64-NEXT: movq (%rsi), %rdx
; X64-NEXT: movq 8(%rsi), %r8 ; X64-NEXT: movq 8(%rsi), %rbp
; X64-NEXT: movq %r11, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %r10 ; X64-NEXT: movq %rdx, %r8
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: movq %rbp, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r11, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rsi, %r9 ; X64-NEXT: movq %rsi, %r10
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %rsi ; X64-NEXT: movq %rax, %rsi
; X64-NEXT: addq %r10, %rsi ; X64-NEXT: addq %r8, %rsi
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: adcq $0, %rbx
; X64-NEXT: movq %r11, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: movq %r11, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r14, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %r12 ; X64-NEXT: movq %rax, %r9
; X64-NEXT: addq %rsi, %r12 ; X64-NEXT: addq %rsi, %r9
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rbx, %rcx
; X64-NEXT: addq %rbx, %rcx
; X64-NEXT: sbbq %rbx, %rbx ; X64-NEXT: sbbq %rbx, %rbx
; X64-NEXT: andl $1, %ebx ; X64-NEXT: andl $1, %ebx
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rbp, %r8
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rcx, %rbp ; X64-NEXT: addq %rcx, %rbp
; X64-NEXT: adcq %rbx, %rsi ; X64-NEXT: adcq %rbx, %rsi
; X64-NEXT: xorl %ecx, %ecx ; X64-NEXT: xorl %ecx, %ecx
; X64-NEXT: movq %r9, %rbx ; X64-NEXT: movq %r10, %rbx
; X64-NEXT: movq %rbx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rbx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rbx, %rax ; X64-NEXT: movq %rbx, %rax
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %r13 ; X64-NEXT: movq %rdx, %r13
; X64-NEXT: movq %rax, %r10 ; X64-NEXT: movq %rax, %r10
; X64-NEXT: movq %r11, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, %r9 ; X64-NEXT: movq %rdx, %r12
; X64-NEXT: movq %r9, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r12, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rax, %r15 ; X64-NEXT: movq %rax, %r15
; X64-NEXT: movq %r15, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r15, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: addq %r10, %r15 ; X64-NEXT: addq %r10, %r15
; X64-NEXT: adcq %r13, %r9 ; X64-NEXT: adcq %r13, %r12
; X64-NEXT: addq %rbp, %r15 ; X64-NEXT: addq %rbp, %r15
; X64-NEXT: adcq %rsi, %r9 ; X64-NEXT: adcq %rsi, %r12
; X64-NEXT: movq %rdi, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq (%rdi), %r14 ; X64-NEXT: movq (%rdi), %r14
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: mulq %rbx ; X64-NEXT: mulq %rbx
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rdx, %r11 ; X64-NEXT: movq %rdx, %r11
; X64-NEXT: movq 8(%rdi), %rcx ; X64-NEXT: movq 8(%rdi), %rcx
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %rbx ; X64-NEXT: mulq %rbx
; X64-NEXT: movq %rdx, %rbp ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %rsi ; X64-NEXT: movq %rax, %rsi
; X64-NEXT: addq %r11, %rsi ; X64-NEXT: addq %r11, %rsi
; X64-NEXT: adcq $0, %rbp ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: movq %r14, %rax ; X64-NEXT: movq %r14, %rax
; X64-NEXT: movq %r8, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r8, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: addq %rsi, %rax ; X64-NEXT: addq %rsi, %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: adcq %rbp, %rbx
; X64-NEXT: addq %rbp, %rbx
; X64-NEXT: sbbq %rdi, %rdi ; X64-NEXT: sbbq %rdi, %rdi
; X64-NEXT: andl $1, %edi ; X64-NEXT: andl $1, %edi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rbx, %rbp ; X64-NEXT: addq %rbx, %rbp
; X64-NEXT: adcq %rdi, %rsi ; X64-NEXT: adcq %rdi, %rsi
; X64-NEXT: movq %r14, %rcx ; X64-NEXT: movq %r14, %rcx
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: xorl %edx, %edx ; X64-NEXT: xorl %edx, %edx
; X64-NEXT: mulq %rdx ; X64-NEXT: mulq %rdx
; X64-NEXT: movq %rdx, %r14 ; X64-NEXT: movq %rdx, %r14
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq %rax, %r11
; X64-NEXT: addq %r11, %r10 ; X64-NEXT: addq %r11, %r10
; X64-NEXT: adcq %r14, %r13 ; X64-NEXT: adcq %r14, %r13
; X64-NEXT: addq %rbp, %r10 ; X64-NEXT: addq %rbp, %r10
; X64-NEXT: adcq %rsi, %r13 ; X64-NEXT: adcq %rsi, %r13
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %r10 # 8-byte Folded Reload
; X64-NEXT: adcq %r12, %r13 ; X64-NEXT: adcq %r9, %r13
; X64-NEXT: adcq $0, %r15 ; X64-NEXT: adcq $0, %r15
; X64-NEXT: adcq $0, %r9 ; X64-NEXT: adcq $0, %r12
; X64-NEXT: movq %r9, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: movq 16(%rsi), %r8 ; X64-NEXT: movq 16(%rsi), %r8
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %rcx, %r9 ; X64-NEXT: movq %rcx, %r9
; X64-NEXT: movq %r9, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %r9, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: movq %rax, %r12 ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %rdi, %rbp ; X64-NEXT: addq %rdi, %rbx
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: adcq $0, %rbp
; X64-NEXT: movq 24(%rsi), %rdi ; X64-NEXT: movq 24(%rsi), %rdi
; X64-NEXT: movq %r9, %rax ; X64-NEXT: movq %r9, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: addq %rbp, %rax ; X64-NEXT: addq %rbx, %rax
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq %rbp, %rsi
; X64-NEXT: addq %rbx, %rsi
; X64-NEXT: sbbq %rbp, %rbp ; X64-NEXT: sbbq %rbp, %rbp
; X64-NEXT: andl $1, %ebp ; X64-NEXT: andl $1, %ebp
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r9
; X64-NEXT: addq %rsi, %r9 ; X64-NEXT: addq %rsi, %r9
; X64-NEXT: adcq %rbp, %rbx ; X64-NEXT: adcq %rbp, %rbx
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r8, %rax
; X64-NEXT: xorl %ecx, %ecx ; X64-NEXT: xorl %ecx, %ecx
; X64-NEXT: mulq %rcx ; X64-NEXT: mulq %rcx
; X64-NEXT: movq %rdx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rdx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rbp, %r11 ; X64-NEXT: addq %rbp, %r11
; X64-NEXT: adcq %rdx, %r14 ; X64-NEXT: adcq %rdx, %r14
; X64-NEXT: addq %r9, %r11 ; X64-NEXT: addq %r9, %r11
; X64-NEXT: adcq %rbx, %r14 ; X64-NEXT: adcq %rbx, %r14
; X64-NEXT: addq %r10, %r12 ; X64-NEXT: addq %r10, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: movq %r12, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r13, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill ; X64-NEXT: adcq %r13, -{{[0-9]+}}(%rsp) # 8-byte Folded Spill
; X64-NEXT: adcq $0, %r11 ; X64-NEXT: adcq $0, %r11
; X64-NEXT: adcq $0, %r14 ; X64-NEXT: adcq $0, %r14
; X64-NEXT: addq %r15, %r11 ; X64-NEXT: addq %r15, %r11
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %r14 # 8-byte Folded Reload ; X64-NEXT: adcq %r12, %r14
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq $0, %rcx
; X64-NEXT: movq %rcx, %r13 ; X64-NEXT: movq %rcx, %r13
; X64-NEXT: sbbq %r9, %r9 ; X64-NEXT: sbbq %r9, %r9
; X64-NEXT: andl $1, %r9d ; X64-NEXT: andl $1, %r9d
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %r15 ; X64-NEXT: movq %rdx, %r15
; X64-NEXT: movq %rax, %r12 ; X64-NEXT: movq %rax, %r12
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r10 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: movq %r10, %rax ; X64-NEXT: movq %r10, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: addq %r15, %rbx ; X64-NEXT: addq %r15, %rbx
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: addq %rbx, %rax ; X64-NEXT: addq %rbx, %rax
; X64-NEXT: movq %rax, %rbx ; X64-NEXT: movq %rax, %rbx
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rsi, %rcx
; X64-NEXT: addq %rsi, %rcx
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %r10, %rax ; X64-NEXT: movq %r10, %rax
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rsi, %rdx ; X64-NEXT: adcq %rsi, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rsi # 8-byte Reload
; X64-NEXT: addq %rbp, %rsi ; X64-NEXT: addq %rbp, %rsi
Show All 9 Lines
; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rsi, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: adcq %r9, %rcx ; X64-NEXT: adcq %r9, %rcx
; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rcx, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq 32(%rcx), %rsi ; X64-NEXT: movq 32(%rcx), %rsi
; X64-NEXT: imulq %rsi, %rdi ; X64-NEXT: imulq %rsi, %rdi
; X64-NEXT: movq %rsi, %rax ; X64-NEXT: movq %rsi, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq %rax, %r10
; X64-NEXT: addq %rdi, %rdx ; X64-NEXT: addq %rdi, %rdx
; X64-NEXT: movq 40(%rcx), %r9 ; X64-NEXT: movq 40(%rcx), %r9
; X64-NEXT: imulq %r9, %r8 ; X64-NEXT: imulq %r9, %r8
; X64-NEXT: addq %rdx, %r8 ; X64-NEXT: addq %rdx, %r8
; X64-NEXT: movq 48(%rcx), %rax ; X64-NEXT: movq 48(%rcx), %rax
; X64-NEXT: movq %rcx, %rbx ; X64-NEXT: movq %rcx, %rbx
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r11 # 8-byte Reload
; X64-NEXT: imulq %r11, %rdi
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rcx # 8-byte Reload
; X64-NEXT: imulq %rcx, %rdi ; X64-NEXT: mulq %rcx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: mulq %rbp
; X64-NEXT: movq %rax, %r12 ; X64-NEXT: movq %rax, %r12
; X64-NEXT: addq %rdi, %rdx ; X64-NEXT: addq %rdi, %rdx
; X64-NEXT: movq 56(%rbx), %rbx ; X64-NEXT: movq 56(%rbx), %rbx
; X64-NEXT: imulq %rbp, %rbx ; X64-NEXT: imulq %rcx, %rbx
; X64-NEXT: addq %rdx, %rbx ; X64-NEXT: addq %rdx, %rbx
; X64-NEXT: addq %r11, %r12 ; X64-NEXT: addq %r10, %r12
; X64-NEXT: adcq %r8, %rbx ; X64-NEXT: adcq %r8, %rbx
; X64-NEXT: movq %rbp, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: movq %rbp, %r8
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill ; X64-NEXT: movq %rax, -{{[0-9]+}}(%rsp) # 8-byte Spill
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rsi ; X64-NEXT: movq %rdx, %rsi
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rdi, %rbp ; X64-NEXT: addq %rdi, %rbp
; X64-NEXT: adcq $0, %rsi ; X64-NEXT: adcq $0, %rsi
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: mulq %r9 ; X64-NEXT: mulq %r9
; X64-NEXT: movq %rdx, %rdi ; X64-NEXT: movq %rdx, %rdi
; X64-NEXT: movq %rax, %r11 ; X64-NEXT: movq %rax, %r15
; X64-NEXT: addq %rbp, %r11 ; X64-NEXT: addq %rbp, %r15
; X64-NEXT: adcq $0, %rdi ; X64-NEXT: adcq %rsi, %rdi
; X64-NEXT: addq %rsi, %rdi
; X64-NEXT: sbbq %rsi, %rsi ; X64-NEXT: sbbq %rsi, %rsi
; X64-NEXT: andl $1, %esi ; X64-NEXT: andl $1, %esi
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %r11, %rax
; X64-NEXT: mulq %r9 ; X64-NEXT: mulq %r9
; X64-NEXT: movq %rdx, %r14 ; X64-NEXT: movq %rdx, %r11
; X64-NEXT: movq %rax, %r15 ; X64-NEXT: movq %rax, %r14
; X64-NEXT: addq %rdi, %r15 ; X64-NEXT: addq %rdi, %r14
; X64-NEXT: adcq %rsi, %r14 ; X64-NEXT: adcq %rsi, %r11
; X64-NEXT: addq %r12, %r15 ; X64-NEXT: addq %r12, %r14
; X64-NEXT: adcq %rbx, %r14 ; X64-NEXT: adcq %rbx, %r11
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdx # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rdx # 8-byte Reload
; X64-NEXT: movq 56(%rdx), %rcx ; X64-NEXT: movq 56(%rdx), %rcx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r8 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r10 # 8-byte Reload
; X64-NEXT: imulq %r8, %rcx ; X64-NEXT: imulq %r10, %rcx
; X64-NEXT: movq 48(%rdx), %rbp ; X64-NEXT: movq 48(%rdx), %rbx
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rbp
; X64-NEXT: movq %r8, %rax ; X64-NEXT: movq %r10, %rax
; X64-NEXT: mulq %rbp ; X64-NEXT: mulq %rbx
; X64-NEXT: movq %rax, %rsi ; X64-NEXT: movq %rax, %rsi
; X64-NEXT: addq %rcx, %rdx ; X64-NEXT: addq %rcx, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r10 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r8 # 8-byte Reload
; X64-NEXT: imulq %r10, %rbp ; X64-NEXT: imulq %r8, %rbx
; X64-NEXT: addq %rdx, %rbp ; X64-NEXT: addq %rdx, %rbx
; X64-NEXT: movq 32(%rbx), %rdi ; X64-NEXT: movq 32(%rbp), %rdi
; X64-NEXT: movq 40(%rbx), %r12 ; X64-NEXT: movq 40(%rbp), %r12
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rax # 8-byte Reload
; X64-NEXT: movq %rax, %rcx ; X64-NEXT: movq %rax, %rcx
; X64-NEXT: imulq %r12, %rcx ; X64-NEXT: imulq %r12, %rcx
; X64-NEXT: mulq %rdi ; X64-NEXT: mulq %rdi
; X64-NEXT: movq %rax, %r9 ; X64-NEXT: movq %rax, %r9
; X64-NEXT: addq %rcx, %rdx ; X64-NEXT: addq %rcx, %rdx
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r13 # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %r13 # 8-byte Reload
; X64-NEXT: imulq %rdi, %r13 ; X64-NEXT: imulq %rdi, %r13
; X64-NEXT: addq %rdx, %r13 ; X64-NEXT: addq %rdx, %r13
; X64-NEXT: addq %rsi, %r9 ; X64-NEXT: addq %rsi, %r9
; X64-NEXT: adcq %rbp, %r13 ; X64-NEXT: adcq %rbx, %r13
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r10
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %rsi ; X64-NEXT: movq %rax, %rsi
; X64-NEXT: movq %r12, %rax ; X64-NEXT: movq %r12, %rax
; X64-NEXT: mulq %r8 ; X64-NEXT: mulq %r10
; X64-NEXT: movq %rdx, %rbx ; X64-NEXT: movq %rdx, %rbx
; X64-NEXT: movq %rax, %rbp ; X64-NEXT: movq %rax, %rbp
; X64-NEXT: addq %rcx, %rbp ; X64-NEXT: addq %rcx, %rbp
; X64-NEXT: adcq $0, %rbx ; X64-NEXT: adcq $0, %rbx
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %r10 ; X64-NEXT: mulq %r8
; X64-NEXT: movq %rdx, %rcx ; X64-NEXT: movq %rdx, %rcx
; X64-NEXT: movq %rax, %rdi ; X64-NEXT: movq %rax, %rdi
; X64-NEXT: addq %rbp, %rdi ; X64-NEXT: addq %rbp, %rdi
; X64-NEXT: adcq $0, %rcx ; X64-NEXT: adcq %rbx, %rcx
; X64-NEXT: addq %rbx, %rcx ; X64-NEXT: sbbq %rbx, %rbx
; X64-NEXT: sbbq %rbp, %rbp ; X64-NEXT: andl $1, %ebx
; X64-NEXT: andl $1, %ebp
; X64-NEXT: movq %r12, %rax ; X64-NEXT: movq %r12, %rax
; X64-NEXT: mulq %r10 ; X64-NEXT: mulq %r8
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: adcq %rbp, %rdx ; X64-NEXT: adcq %rbx, %rdx
; X64-NEXT: addq %r9, %rax ; X64-NEXT: addq %r9, %rax
; X64-NEXT: adcq %r13, %rdx ; X64-NEXT: adcq %r13, %rdx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: adcq %r11, %rdi ; X64-NEXT: adcq %r15, %rdi
; X64-NEXT: adcq %r15, %rax ; X64-NEXT: adcq %r14, %rax
; X64-NEXT: adcq %r14, %rdx ; X64-NEXT: adcq %r11, %rdx
; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload ; X64-NEXT: addq -{{[0-9]+}}(%rsp), %rsi # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdi # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rax # 8-byte Folded Reload
; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload ; X64-NEXT: adcq -{{[0-9]+}}(%rsp), %rdx # 8-byte Folded Reload
; X64-NEXT: movq (%rsp), %rcx # 8-byte Reload ; X64-NEXT: movq (%rsp), %rcx # 8-byte Reload
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload
; X64-NEXT: movq %rbp, (%rcx) ; X64-NEXT: movq %rbp, (%rcx)
; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload ; X64-NEXT: movq -{{[0-9]+}}(%rsp), %rbp # 8-byte Reload
Show All 23 Lines