void dmatvec(ldm, nrow, ncol, M, vec, Mxvec) int ldm;
int nrow;
int ncol;
double *M;
double *vec;
double *Mxvec;
{
  register double vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7;
  register double *Mki0, *Mki1, *Mki2, *Mki3, *Mki4, *Mki5, *Mki6, *Mki7;
  register int firstcol = 0;
  double *M0;
  int k;
  M0 = &M[0];
  while (firstcol < ncol - 7) {
    Mki0 = M0;
    Mki1 = Mki0 + ldm;
    Mki2 = Mki1 + ldm;
    Mki3 = Mki2 + ldm;
    Mki4 = Mki3 + ldm;
    Mki5 = Mki4 + ldm;
    Mki6 = Mki5 + ldm;
    Mki7 = Mki6 + ldm;
    vi0 = vec[firstcol++];
    vi1 = vec[firstcol++];
    vi2 = vec[firstcol++];
    vi3 = vec[firstcol++];
    vi4 = vec[firstcol++];
    vi5 = vec[firstcol++];
    vi6 = vec[firstcol++];
    vi7 = vec[firstcol++];
    for (k = 0; k < nrow; k++)
      Mxvec[k] += vi0 * Mki0[k] + vi1 * Mki1[k] + vi2 * Mki2[k] +
                  vi3 * Mki3[k] + vi4 * Mki4[k] + vi5 * Mki5[k] +
                  vi6 * Mki6[k] + vi7 * Mki7[k];
    M0 += 8 * ldm;
  }
  while (firstcol < ncol - 3) {
    Mki0 = M0;
    Mki1 = Mki0 + ldm;
    Mki2 = Mki1 + ldm;
    Mki3 = Mki2 + ldm;
    vi0 = vec[firstcol++];
    vi1 = vec[firstcol++];
    vi2 = vec[firstcol++];
    vi3 = vec[firstcol++];
    for (k = 0; k < nrow; k++)
      Mxvec[k] += vi0 * Mki0[k] + vi1 * Mki1[k] + vi2 * Mki2[k] + vi3 * Mki3[k];
    M0 += 4 * ldm;
  }
  while (firstcol < ncol) {
    Mki0 = M0;
    vi0 = vec[firstcol++];
    for (k = 0; k < nrow; k++)
      Mxvec[k] += vi0 * Mki0[k];
    M0 += ldm;
  }
}


x86 assembly (clang, -O0):
<dmatvec>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xac(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    1455 <dmatvec+0x355>
mov    -0xb8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1432 <dmatvec+0x332>
movsd  -0x30(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
mov    -0x80(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x88(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
mov    -0x90(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
mov    -0xa0(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xbc(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    130b <dmatvec+0x20b>
mov    -0x4(%rbp),%ecx
shl    $0x3,%ecx
mov    -0xb8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
jmp    1132 <dmatvec+0x32>
jmp    145a <dmatvec+0x35a>
mov    -0xac(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1611 <dmatvec+0x511>
mov    -0xb8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15ee <dmatvec+0x4ee>
movsd  -0x30(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
mov    -0x80(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x88(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xbc(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1547 <dmatvec+0x447>
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
mov    -0xb8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
jmp    145a <dmatvec+0x35a>
jmp    1616 <dmatvec+0x516>
mov    -0xac(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16d1 <dmatvec+0x5d1>
mov    -0xb8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xac(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16b1 <dmatvec+0x5b1>
movsd  -0x30(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    165c <dmatvec+0x55c>
mov    -0x4(%rbp),%ecx
mov    -0xb8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
jmp    1616 <dmatvec+0x516>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dmatvec>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r8,0x50(%rsp)
mov    %rcx,%r14
movslq %edi,%r8
mov    %esi,-0x6c(%rsp)
mov    %esi,%edi
cmp    $0x8,%edx
mov    %rdi,-0x78(%rsp)
mov    %rdx,0x58(%rsp)
jl     1790 <dmatvec+0x690>
lea    -0x7(%rdx),%eax
mov    %rax,0x48(%rsp)
lea    0x0(,%r8,8),%eax
cltq
lea    (%r9,%rdi,8),%rcx
mov    %rcx,0xd0(%rsp)
lea    (%r8,%r8,4),%rcx
lea    (%rcx,%rdi,1),%rdx
mov    %rdx,0xc0(%rsp)
lea    0x0(,%r8,4),%rdx
mov    %rdx,0xb8(%rsp)
lea    (%rdi,%r8,4),%rdx
mov    %rdx,0xb0(%rsp)
lea    (%r8,%r8,2),%rdx
lea    (%rdx,%rdi,1),%rsi
mov    %rsi,0xa0(%rsp)
lea    (%r8,%r8,1),%rsi
lea    0x0(,%r8,8),%r13
mov    %r13,%rbp
sub    %r8,%rbp
mov    %edi,%ebx
and    $0xfffffffe,%ebx
mov    %rbx,0x60(%rsp)
mov    %r8,%rbx
shl    $0x5,%rbx
add    %r14,%rbx
mov    %rbx,-0x18(%rsp)
mov    %r8,%rbx
shl    $0x4,%rbx
add    %r14,%rbx
mov    %rbx,-0x20(%rsp)
lea    (%rdi,%r8,2),%rbx
mov    %rbx,0x88(%rsp)
lea    (%r8,%rdi,1),%rbx
mov    %rbx,0x80(%rsp)
mov    %rsi,0x98(%rsp)
lea    (%rsi,%rsi,2),%rsi
lea    (%rsi,%rdi,1),%rbx
mov    %rbx,0x70(%rsp)
add    %rbp,%rdi
mov    %rdi,0x68(%rsp)
mov    %rax,0xd8(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0xf0(%rsp)
mov    %rbp,0x90(%rsp)
lea    (%r14,%rbp,8),%rax
mov    %rax,-0x28(%rsp)
mov    %rsi,0x78(%rsp)
lea    (%r14,%rsi,8),%rax
mov    %rax,-0x30(%rsp)
mov    %rcx,0xc8(%rsp)
lea    (%r14,%rcx,8),%rax
mov    %rax,-0x38(%rsp)
mov    %rdx,0xa8(%rsp)
lea    (%r14,%rdx,8),%rax
mov    %rax,-0x40(%rsp)
lea    (%r14,%r8,8),%rax
mov    %rax,-0x48(%rsp)
xor    %eax,%eax
mov    %rax,-0x50(%rsp)
mov    %r14,-0x60(%rsp)
xor    %r10d,%r10d
jmp    12c9 <dmatvec+0x1c9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xf0(%rsp),%rax
mov    -0x58(%rsp),%r14
add    %rax,%r14
addq   $0x1,-0x50(%rsp)
add    %rax,-0x28(%rsp)
add    %rax,-0x30(%rsp)
add    %rax,-0x38(%rsp)
add    %rax,-0x18(%rsp)
add    %rax,-0x40(%rsp)
add    %rax,-0x20(%rsp)
add    %rax,-0x48(%rsp)
mov    -0x68(%rsp),%r10
cmp    0x48(%rsp),%r10
jae    1799 <dmatvec+0x699>
mov    %r14,-0x58(%rsp)
lea    0x8(%r10),%rax
mov    %rax,-0x68(%rsp)
cmpl   $0x0,-0x6c(%rsp)
jle    1280 <dmatvec+0x180>
lea    0x0(,%r10,8),%rcx
mov    %rcx,%r11
or     $0x8,%r11
mov    %rcx,%rsi
or     $0x10,%rsi
mov    %rcx,%rdi
or     $0x18,%rdi
mov    %rcx,%rbp
or     $0x20,%rbp
mov    %rcx,%rbx
or     $0x28,%rbx
mov    %rcx,%rax
or     $0x30,%rax
or     $0x38,%rcx
mov    0x50(%rsp),%rdx
movsd  (%rdx,%r10,8),%xmm15
movsd  (%rdx,%r11,1),%xmm10
movsd  (%rdx,%rsi,1),%xmm11
movsd  (%rdx,%rdi,1),%xmm3
movsd  (%rdx,%rbp,1),%xmm4
movsd  (%rdx,%rbx,1),%xmm5
movsd  (%rdx,%rax,1),%xmm6
movsd  (%rdx,%rcx,1),%xmm7
cmpl   $0x1,-0x6c(%rsp)
jne    1440 <dmatvec+0x340>
xor    %r14d,%r14d
lea    (%r9,%r14,8),%rdi
mov    -0x28(%rsp),%rcx
lea    (%rcx,%r14,8),%rbp
mov    -0x30(%rsp),%rcx
lea    (%rcx,%r14,8),%rcx
mov    -0x38(%rsp),%rdx
lea    (%rdx,%r14,8),%r11
mov    -0x18(%rsp),%rdx
lea    (%rdx,%r14,8),%r15
mov    -0x40(%rsp),%rdx
lea    (%rdx,%r14,8),%rdx
mov    -0x20(%rsp),%rsi
lea    (%rsi,%r14,8),%rbx
mov    -0x48(%rsp),%rsi
lea    (%rsi,%r14,8),%rsi
mov    -0x58(%rsp),%rax
lea    (%rax,%r14,8),%r10
mov    -0x78(%rsp),%r12
sub    %r14,%r12
xor    %r14d,%r14d
nopl   0x0(%rax)
movsd  (%rsi,%r14,8),%xmm0
mulsd  %xmm10,%xmm0
movsd  (%r10,%r14,8),%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rbx,%r14,8),%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rdx,%r14,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r15,%r14,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r11,%r14,8),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rcx,%r14,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
movsd  0x0(%rbp,%r14,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
addsd  (%rdi,%r14,8),%xmm1
movsd  %xmm1,(%rdi,%r14,8)
add    $0x1,%r14
cmp    %r14,%r12
jne    13b0 <dmatvec+0x2b0>
jmp    1280 <dmatvec+0x180>
xchg   %ax,%ax
mov    -0x50(%rsp),%rcx
imul   0xd8(%rsp),%rcx
mov    0xc8(%rsp),%rax
add    %rcx,%rax
mov    0xc0(%rsp),%rdx
lea    (%rdx,%rcx,1),%rbx
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rcx,1),%rsi
mov    0xb0(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdi
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdx
mov    %rdx,0x38(%rsp)
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdx
mov    0x98(%rsp),%rbp
lea    0x0(%rbp,%rcx,1),%rbp
mov    %rbp,0x40(%rsp)
mov    0x88(%rsp),%rbp
lea    0x0(%rbp,%rcx,1),%r10
lea    (%rcx,%r8,1),%rbp
mov    %rbp,(%rsp)
mov    0x80(%rsp),%rbp
lea    0x0(%rbp,%rcx,1),%rbp
mov    %rbp,0xe0(%rsp)
mov    -0x78(%rsp),%rbp
lea    (%rcx,%rbp,1),%rbp
mov    %rbp,-0x10(%rsp)
mov    0x78(%rsp),%rbp
add    %rcx,%rbp
mov    %rbp,0x10(%rsp)
mov    0x70(%rsp),%rbp
add    %rcx,%rbp
mov    %rbp,0xe8(%rsp)
mov    0x90(%rsp),%rbp
add    %rcx,%rbp
mov    %rbp,0x20(%rsp)
add    0x68(%rsp),%rcx
mov    -0x60(%rsp),%r14
lea    (%r14,%rbx,8),%rbx
cmp    %r9,%rbx
seta   -0x79(%rsp)
lea    (%r14,%rax,8),%rax
mov    0xd0(%rsp),%r15
cmp    %r15,%rax
lea    (%r14,%rdi,8),%rax
setb   %r11b
cmp    %r9,%rax
lea    (%r14,%rsi,8),%rsi
seta   %al
cmp    %r15,%rsi
lea    (%r14,%rdx,8),%rdx
setb   %r12b
cmp    %r9,%rdx
mov    0x38(%rsp),%rdx
lea    (%r14,%rdx,8),%rsi
seta   %dl
cmp    %r15,%rsi
lea    (%r14,%r10,8),%rsi
setb   0x38(%rsp)
cmp    %r9,%rsi
mov    0x40(%rsp),%rsi
lea    (%r14,%rsi,8),%rsi
seta   %bl
cmp    %r15,%rsi
mov    0xe0(%rsp),%rsi
lea    (%r14,%rsi,8),%rsi
setb   0x40(%rsp)
cmp    %r9,%rsi
seta   %sil
mov    (%rsp),%rdi
lea    (%r14,%rdi,8),%rdi
cmp    %r15,%rdi
mov    -0x10(%rsp),%rdi
lea    (%r14,%rdi,8),%rdi
mov    0xe8(%rsp),%rbp
lea    (%r14,%rbp,8),%rbp
setb   (%rsp)
cmp    %r9,%rdi
seta   %dil
cmp    %r15,-0x58(%rsp)
setb   -0x10(%rsp)
cmp    %r9,%rbp
mov    0x10(%rsp),%rbp
lea    (%r14,%rbp,8),%rbp
seta   %r10b
cmp    %r15,%rbp
lea    (%r14,%rcx,8),%rcx
setb   0x10(%rsp)
cmp    %r9,%rcx
seta   %cl
mov    0x20(%rsp),%rbp
lea    (%r14,%rbp,8),%rbp
cmp    %r15,%rbp
setb   %bpl
test   %r11b,-0x79(%rsp)
jne    134f <dmatvec+0x24f>
and    %r12b,%al
jne    134f <dmatvec+0x24f>
and    0x38(%rsp),%dl
jne    134f <dmatvec+0x24f>
and    0x40(%rsp),%bl
jne    134f <dmatvec+0x24f>
and    (%rsp),%sil
jne    134f <dmatvec+0x24f>
and    -0x10(%rsp),%dil
jne    134f <dmatvec+0x24f>
and    0x10(%rsp),%r10b
jne    134f <dmatvec+0x24f>
mov    $0x0,%r14d
and    %bpl,%cl
jne    1352 <dmatvec+0x252>
movapd %xmm10,%xmm0
unpcklpd %xmm10,%xmm0
movapd %xmm0,0x20(%rsp)
movapd %xmm15,%xmm0
unpcklpd %xmm15,%xmm0
movapd %xmm0,0x10(%rsp)
movapd %xmm11,%xmm0
unpcklpd %xmm11,%xmm0
movapd %xmm0,(%rsp)
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
movapd %xmm0,-0x10(%rsp)
movapd %xmm4,%xmm12
unpcklpd %xmm4,%xmm12
movapd %xmm5,%xmm13
unpcklpd %xmm5,%xmm13
movapd %xmm6,%xmm14
unpcklpd %xmm6,%xmm14
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
xor    %edi,%edi
mov    0x60(%rsp),%rdx
mov    -0x58(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rax,%rdi,8),%rcx
movupd (%rax,%rdi,8),%xmm8
mulpd  0x10(%rsp),%xmm8
movupd (%rcx,%r8,8),%xmm9
add    %r13,%rcx
mulpd  0x20(%rsp),%xmm9
addpd  %xmm8,%xmm9
movupd (%rcx,%r8,8),%xmm1
add    %r13,%rcx
mulpd  (%rsp),%xmm1
addpd  %xmm9,%xmm1
movupd (%rcx,%r8,8),%xmm2
add    %r13,%rcx
mulpd  -0x10(%rsp),%xmm2
addpd  %xmm1,%xmm2
movupd (%rcx,%r8,8),%xmm1
add    %r13,%rcx
mulpd  %xmm12,%xmm1
addpd  %xmm2,%xmm1
movupd (%rcx,%r8,8),%xmm2
add    %r13,%rcx
mulpd  %xmm13,%xmm2
addpd  %xmm1,%xmm2
movupd (%rcx,%r8,8),%xmm1
add    %r13,%rcx
mulpd  %xmm14,%xmm1
addpd  %xmm2,%xmm1
movupd (%rcx,%r8,8),%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd (%r9,%rdi,8),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,(%r9,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    16d0 <dmatvec+0x5d0>
mov    %rdx,%r14
cmp    -0x78(%rsp),%rdx
je     1280 <dmatvec+0x180>
jmp    1352 <dmatvec+0x252>
xor    %eax,%eax
mov    %rax,-0x68(%rsp)
jmp    17a3 <dmatvec+0x6a3>
mov    0x58(%rsp),%rdx
mov    -0x78(%rsp),%rdi
lea    -0x3(%rdx),%eax
mov    -0x68(%rsp),%rsi
cmp    %eax,%esi
mov    %r14,-0x60(%rsp)
jge    1ab2 <dmatvec+0x9b2>
lea    0x0(,%r8,4),%ecx
movslq %ecx,%rcx
mov    %esi,%esi
cltq
mov    %rax,0x20(%rsp)
lea    (%r9,%rdi,8),%rax
mov    %rax,-0x18(%rsp)
lea    (%r8,%r8,2),%rdx
lea    (%rdx,%rdi,1),%rax
mov    %rax,-0x28(%rsp)
lea    (%r8,%r8,1),%rax
mov    %rax,-0x30(%rsp)
lea    (%rdi,%r8,2),%rax
mov    %rax,-0x38(%rsp)
lea    (%r8,%rdi,1),%rax
mov    %rax,-0x40(%rsp)
and    $0xfffffffe,%edi
mov    %rdi,-0x48(%rsp)
mov    %rcx,-0x58(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x10(%rsp)
mov    %r8,%rcx
shl    $0x4,%rcx
lea    0x0(,%r8,8),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,0x48(%rsp)
mov    %rdx,-0x20(%rsp)
lea    (%r14,%rdx,8),%rax
mov    %rcx,-0x50(%rsp)
lea    (%r14,%rcx,1),%r10
lea    (%r14,%r8,8),%r11
xor    %r15d,%r15d
mov    %rsi,%rdi
jmp    1870 <dmatvec+0x770>
nopl   (%rax)
mov    0x10(%rsp),%rcx
add    %rcx,%r14
add    $0x1,%r15
add    %rcx,%rax
add    %rcx,%r10
add    %rcx,%r11
cmp    0x20(%rsp),%rdi
jge    1abe <dmatvec+0x9be>
mov    %rdi,%rcx
add    $0x4,%rdi
cmpl   $0x0,-0x6c(%rsp)
jle    1850 <dmatvec+0x750>
mov    %ecx,%edx
shl    $0x3,%rdx
mov    %rdx,%rsi
or     $0x8,%rsi
mov    %rdx,%rbx
or     $0x10,%rbx
or     $0x18,%rdx
mov    0x50(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  0x0(%rbp,%rsi,1),%xmm1
movsd  0x0(%rbp,%rbx,1),%xmm2
movsd  0x0(%rbp,%rdx,1),%xmm3
cmpl   $0x1,-0x6c(%rsp)
jne    1930 <dmatvec+0x830>
xor    %ebx,%ebx
lea    (%r9,%rbx,8),%rbp
lea    (%rax,%rbx,8),%r12
lea    (%r10,%rbx,8),%r13
lea    (%r11,%rbx,8),%rsi
lea    (%r14,%rbx,8),%rcx
mov    -0x78(%rsp),%rdx
sub    %rbx,%rdx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rbx,8),%xmm4
mulsd  %xmm1,%xmm4
movsd  (%rcx,%rbx,8),%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
movsd  0x0(%r13,%rbx,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  (%r12,%rbx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
addsd  0x0(%rbp,%rbx,8),%xmm5
movsd  %xmm5,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    18e0 <dmatvec+0x7e0>
jmp    1850 <dmatvec+0x750>
nopl   (%rax)
mov    %rdi,-0x68(%rsp)
mov    %r15,%rcx
imul   -0x58(%rsp),%rcx
mov    -0x20(%rsp),%rdx
add    %rcx,%rdx
mov    -0x28(%rsp),%rsi
add    %rcx,%rsi
mov    -0x30(%rsp),%rdi
lea    (%rdi,%rcx,1),%r13
mov    -0x38(%rsp),%rdi
lea    (%rdi,%rcx,1),%rbp
lea    (%rcx,%r8,1),%rdi
mov    %rdi,(%rsp)
mov    -0x40(%rsp),%rdi
lea    (%rdi,%rcx,1),%rbx
add    -0x78(%rsp),%rcx
mov    -0x60(%rsp),%rdi
lea    (%rdi,%rsi,8),%rsi
cmp    %r9,%rsi
lea    (%rdi,%rdx,8),%rsi
seta   -0x10(%rsp)
mov    -0x18(%rsp),%rdx
cmp    %rdx,%rsi
lea    (%rdi,%rbp,8),%rbp
setb   %sil
cmp    %r9,%rbp
lea    (%rdi,%r13,8),%rbp
seta   %r12b
cmp    %rdx,%rbp
lea    (%rdi,%rbx,8),%rbx
setb   %r13b
cmp    %r9,%rbx
mov    (%rsp),%rbx
lea    (%rdi,%rbx,8),%rbp
seta   %bl
cmp    %rdx,%rbp
lea    (%rdi,%rcx,8),%rcx
setb   %bpl
cmp    %r9,%rcx
seta   %cl
cmp    %rdx,%r14
setb   %dl
test   %sil,-0x10(%rsp)
jne    1aa6 <dmatvec+0x9a6>
and    %r13b,%r12b
jne    1aa6 <dmatvec+0x9a6>
and    %bpl,%bl
mov    -0x68(%rsp),%rdi
jne    18ba <dmatvec+0x7ba>
mov    $0x0,%ebx
and    %dl,%cl
jne    18bc <dmatvec+0x7bc>
movapd %xmm1,%xmm8
unpcklpd %xmm1,%xmm8
movapd %xmm0,%xmm9
unpcklpd %xmm0,%xmm9
movapd %xmm2,%xmm6
unpcklpd %xmm2,%xmm6
movapd %xmm3,%xmm7
unpcklpd %xmm3,%xmm7
mov    %r14,%rbp
xor    %esi,%esi
mov    -0x48(%rsp),%rcx
mov    -0x50(%rsp),%rdx
mov    0x48(%rsp),%rbx
nopl   (%rax)
movupd 0x0(%rbp),%xmm4
mulpd  %xmm9,%xmm4
movupd 0x0(%rbp,%r8,8),%xmm5
mulpd  %xmm8,%xmm5
addpd  %xmm4,%xmm5
movupd 0x0(%rbp,%rdx,1),%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
movupd 0x0(%rbp,%rbx,1),%xmm5
mulpd  %xmm7,%xmm5
addpd  %xmm4,%xmm5
movupd (%r9,%rsi,8),%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%r9,%rsi,8)
add    $0x2,%rsi
add    $0x10,%rbp
cmp    %rsi,%rcx
jne    1a40 <dmatvec+0x940>
mov    %rcx,%rbx
cmp    -0x78(%rsp),%rcx
je     1850 <dmatvec+0x750>
jmp    18bc <dmatvec+0x7bc>
xor    %ebx,%ebx
mov    -0x68(%rsp),%rdi
jmp    18bc <dmatvec+0x7bc>
mov    %rsi,%rdi
cmp    %edx,%edi
jl     1ad0 <dmatvec+0x9d0>
jmp    1cf2 <dmatvec+0xbf2>
mov    %r14,-0x60(%rsp)
mov    0x58(%rsp),%rdx
cmp    %edx,%edi
jge    1cf2 <dmatvec+0xbf2>
mov    %edi,%eax
mov    -0x78(%rsp),%r12
lea    (%r9,%r12,8),%r11
mov    %r12d,%r15d
and    $0xfffffffc,%r15d
lea    -0x4(%r15),%r10
mov    %r10,%r14
shr    $0x2,%r14
add    $0x1,%r14
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x20(%rsp)
neg    %r12
lea    0x0(,%r8,8),%rcx
xor    %edi,%edi
mov    -0x60(%rsp),%rsi
jmp    1b2f <dmatvec+0xa2f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %rcx,%rsi
add    $0x1,%rdi
cmp    %edx,%eax
jge    1cf2 <dmatvec+0xbf2>
mov    %rax,%rbx
add    $0x1,%rax
cmpl   $0x0,-0x6c(%rsp)
jle    1b20 <dmatvec+0xa20>
mov    0x50(%rsp),%rbp
movsd  0x0(%rbp,%rbx,8),%xmm0
cmpl   $0x4,-0x6c(%rsp)
jb     1b7d <dmatvec+0xa7d>
mov    %rdi,%rbx
imul   %r8,%rbx
add    -0x78(%rsp),%rbx
mov    -0x60(%rsp),%rbp
lea    0x0(,%rbx,8),%rbx
add    %rbp,%rbx
cmp    %r9,%rbx
jbe    1bfb <dmatvec+0xafb>
cmp    %r11,%rsi
jae    1bfb <dmatvec+0xafb>
xor    %ebp,%ebp
mov    -0x78(%rsp),%r13
mov    %rbp,%rbx
test   $0x1,%r13b
je     1ba9 <dmatvec+0xaa9>
movsd  (%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r9,%rbp,8),%xmm1
movsd  %xmm1,(%r9,%rbp,8)
mov    %rbp,%rbx
or     $0x1,%rbx
not    %rbp
cmp    %r12,%rbp
mov    -0x78(%rsp),%rbp
je     1b20 <dmatvec+0xa20>
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r9,%rbx,8),%xmm1
movsd  %xmm1,(%r9,%rbx,8)
movsd  0x8(%rsi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r9,%rbx,8),%xmm1
movsd  %xmm1,0x8(%r9,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rbp
jne    1bc0 <dmatvec+0xac0>
jmp    1b20 <dmatvec+0xa20>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
test   %r10,%r10
je     1ce8 <dmatvec+0xbe8>
mov    0x20(%rsp),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rsi,%rbx,8),%xmm2
movupd 0x10(%rsi,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%r9,%rbx,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r9,%rbx,8),%xmm2
movupd 0x20(%r9,%rbx,8),%xmm5
movupd 0x30(%r9,%rbx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%r9,%rbx,8)
movupd %xmm3,0x10(%r9,%rbx,8)
movupd 0x20(%rsi,%rbx,8),%xmm2
movupd 0x30(%rsi,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%r9,%rbx,8)
movupd %xmm3,0x30(%r9,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1c20 <dmatvec+0xb20>
test   $0x1,%r14b
je     1cd2 <dmatvec+0xbd2>
movupd (%rsi,%rbx,8),%xmm2
movupd 0x10(%rsi,%rbx,8),%xmm3
movupd (%r9,%rbx,8),%xmm4
movupd 0x10(%r9,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r9,%rbx,8)
movupd %xmm3,0x10(%r9,%rbx,8)
mov    %r15,%rbp
mov    -0x78(%rsp),%r13
cmp    %r13,%r15
je     1b20 <dmatvec+0xa20>
jmp    1b84 <dmatvec+0xa84>
xor    %ebx,%ebx
test   $0x1,%r14b
jne    1c9d <dmatvec+0xb9d>
jmp    1cd2 <dmatvec+0xbd2>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @dmatvec(i32 %0, i32 %1, i32 %2, double* %3, double* %4, double* %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca i32
%30 = alloca double*
%31 = alloca i32
store i32 %0, i32* %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store double* %3, double** %10
store double* %4, double** %11
store double* %5, double** %12
store i32 0, i32* %29
%32 = load double*, double** %10
%33 = getelementptr inbounds double, double* %32, i64 0
store double* %33, double** %30
br label %34
34: ; preds = %187, %6
%35 = load i32, i32* %29
%36 = load i32, i32* %9
%37 = sub nsw i32 %36, 7
%38 = icmp slt i32 %35, %37
br i1 %38, label %39, label %193
39: ; preds = %34
%40 = load double*, double** %30
store double* %40, double** %21
%41 = load double*, double** %21
%42 = load i32, i32* %7
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %41, i64 %43
store double* %44, double** %22
%45 = load double*, double** %22
%46 = load i32, i32* %7
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double, double* %45, i64 %47
store double* %48, double** %23
%49 = load double*, double** %23
%50 = load i32, i32* %7
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
store double* %52, double** %24
%53 = load double*, double** %24
%54 = load i32, i32* %7
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %53, i64 %55
store double* %56, double** %25
%57 = load double*, double** %25
%58 = load i32, i32* %7
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
store double* %60, double** %26
%61 = load double*, double** %26
%62 = load i32, i32* %7
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds double, double* %61, i64 %63
store double* %64, double** %27
%65 = load double*, double** %27
%66 = load i32, i32* %7
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %65, i64 %67
store double* %68, double** %28
%69 = load double*, double** %11
%70 = load i32, i32* %29
%71 = add nsw i32 %70, 1
store i32 %71, i32* %29
%72 = sext i32 %70 to i64
%73 = getelementptr inbounds double, double* %69, i64 %72
%74 = load double, double* %73
store double %74, double* %13
%75 = load double*, double** %11
%76 = load i32, i32* %29
%77 = add nsw i32 %76, 1
store i32 %77, i32* %29
%78 = sext i32 %76 to i64
%79 = getelementptr inbounds double, double* %75, i64 %78
%80 = load double, double* %79
store double %80, double* %14
%81 = load double*, double** %11
%82 = load i32, i32* %29
%83 = add nsw i32 %82, 1
store i32 %83, i32* %29
%84 = sext i32 %82 to i64
%85 = getelementptr inbounds double, double* %81, i64 %84
%86 = load double, double* %85
store double %86, double* %15
%87 = load double*, double** %11
%88 = load i32, i32* %29
%89 = add nsw i32 %88, 1
store i32 %89, i32* %29
%90 = sext i32 %88 to i64
%91 = getelementptr inbounds double, double* %87, i64 %90
%92 = load double, double* %91
store double %92, double* %16
%93 = load double*, double** %11
%94 = load i32, i32* %29
%95 = add nsw i32 %94, 1
store i32 %95, i32* %29
%96 = sext i32 %94 to i64
%97 = getelementptr inbounds double, double* %93, i64 %96
%98 = load double, double* %97
store double %98, double* %17
%99 = load double*, double** %11
%100 = load i32, i32* %29
%101 = add nsw i32 %100, 1
store i32 %101, i32* %29
%102 = sext i32 %100 to i64
%103 = getelementptr inbounds double, double* %99, i64 %102
%104 = load double, double* %103
store double %104, double* %18
%105 = load double*, double** %11
%106 = load i32, i32* %29
%107 = add nsw i32 %106, 1
store i32 %107, i32* %29
%108 = sext i32 %106 to i64
%109 = getelementptr inbounds double, double* %105, i64 %108
%110 = load double, double* %109
store double %110, double* %19
%111 = load double*, double** %11
%112 = load i32, i32* %29
%113 = add nsw i32 %112, 1
store i32 %113, i32* %29
%114 = sext i32 %112 to i64
%115 = getelementptr inbounds double, double* %111, i64 %114
%116 = load double, double* %115
store double %116, double* %20
store i32 0, i32* %31
br label %117
117: ; preds = %184, %39
%118 = load i32, i32* %31
%119 = load i32, i32* %8
%120 = icmp slt i32 %118, %119
br i1 %120, label %121, label %187
121: ; preds = %117
%122 = load double, double* %13
%123 = load double*, double** %21
%124 = load i32, i32* %31
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
%127 = load double, double* %126
%128 = load double, double* %14
%129 = load double*, double** %22
%130 = load i32, i32* %31
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %129, i64 %131
%133 = load double, double* %132
%134 = fmul double %128, %133
%135 = call double @llvm.fmuladd.f64(double %122, double %127, double %134)
%136 = load double, double* %15
%137 = load double*, double** %23
%138 = load i32, i32* %31
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds double, double* %137, i64 %139
%141 = load double, double* %140
%142 = call double @llvm.fmuladd.f64(double %136, double %141, double %135)
%143 = load double, double* %16
%144 = load double*, double** %24
%145 = load i32, i32* %31
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %144, i64 %146
%148 = load double, double* %147
%149 = call double @llvm.fmuladd.f64(double %143, double %148, double %142)
%150 = load double, double* %17
%151 = load double*, double** %25
%152 = load i32, i32* %31
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %151, i64 %153
%155 = load double, double* %154
%156 = call double @llvm.fmuladd.f64(double %150, double %155, double %149)
%157 = load double, double* %18
%158 = load double*, double** %26
%159 = load i32, i32* %31
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds double, double* %158, i64 %160
%162 = load double, double* %161
%163 = call double @llvm.fmuladd.f64(double %157, double %162, double %156)
%164 = load double, double* %19
%165 = load double*, double** %27
%166 = load i32, i32* %31
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds double, double* %165, i64 %167
%169 = load double, double* %168
%170 = call double @llvm.fmuladd.f64(double %164, double %169, double %163)
%171 = load double, double* %20
%172 = load double*, double** %28
%173 = load i32, i32* %31
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %172, i64 %174
%176 = load double, double* %175
%177 = call double @llvm.fmuladd.f64(double %171, double %176, double %170)
%178 = load double*, double** %12
%179 = load i32, i32* %31
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %178, i64 %180
%182 = load double, double* %181
%183 = fadd double %182, %177
store double %183, double* %181
br label %184
184: ; preds = %121
%185 = load i32, i32* %31
%186 = add nsw i32 %185, 1
store i32 %186, i32* %31
br label %117
187: ; preds = %117
%188 = load i32, i32* %7
%189 = mul nsw i32 8, %188
%190 = load double*, double** %30
%191 = sext i32 %189 to i64
%192 = getelementptr inbounds double, double* %190, i64 %191
store double* %192, double** %30
br label %34
193: ; preds = %34
br label %194
194: ; preds = %279, %193
%195 = load i32, i32* %29
%196 = load i32, i32* %9
%197 = sub nsw i32 %196, 3
%198 = icmp slt i32 %195, %197
br i1 %198, label %199, label %285
199: ; preds = %194
%200 = load double*, double** %30
store double* %200, double** %21
%201 = load double*, double** %21
%202 = load i32, i32* %7
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %201, i64 %203
store double* %204, double** %22
%205 = load double*, double** %22
%206 = load i32, i32* %7
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %205, i64 %207
store double* %208, double** %23
%209 = load double*, double** %23
%210 = load i32, i32* %7
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %209, i64 %211
store double* %212, double** %24
%213 = load double*, double** %11
%214 = load i32, i32* %29
%215 = add nsw i32 %214, 1
store i32 %215, i32* %29
%216 = sext i32 %214 to i64
%217 = getelementptr inbounds double, double* %213, i64 %216
%218 = load double, double* %217
store double %218, double* %13
%219 = load double*, double** %11
%220 = load i32, i32* %29
%221 = add nsw i32 %220, 1
store i32 %221, i32* %29
%222 = sext i32 %220 to i64
%223 = getelementptr inbounds double, double* %219, i64 %222
%224 = load double, double* %223
store double %224, double* %14
%225 = load double*, double** %11
%226 = load i32, i32* %29
%227 = add nsw i32 %226, 1
store i32 %227, i32* %29
%228 = sext i32 %226 to i64
%229 = getelementptr inbounds double, double* %225, i64 %228
%230 = load double, double* %229
store double %230, double* %15
%231 = load double*, double** %11
%232 = load i32, i32* %29
%233 = add nsw i32 %232, 1
store i32 %233, i32* %29
%234 = sext i32 %232 to i64
%235 = getelementptr inbounds double, double* %231, i64 %234
%236 = load double, double* %235
store double %236, double* %16
store i32 0, i32* %31
br label %237
237: ; preds = %276, %199
%238 = load i32, i32* %31
%239 = load i32, i32* %8
%240 = icmp slt i32 %238, %239
br i1 %240, label %241, label %279
241: ; preds = %237
%242 = load double, double* %13
%243 = load double*, double** %21
%244 = load i32, i32* %31
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %243, i64 %245
%247 = load double, double* %246
%248 = load double, double* %14
%249 = load double*, double** %22
%250 = load i32, i32* %31
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds double, double* %249, i64 %251
%253 = load double, double* %252
%254 = fmul double %248, %253
%255 = call double @llvm.fmuladd.f64(double %242, double %247, double %254)
%256 = load double, double* %15
%257 = load double*, double** %23
%258 = load i32, i32* %31
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double, double* %257, i64 %259
%261 = load double, double* %260
%262 = call double @llvm.fmuladd.f64(double %256, double %261, double %255)
%263 = load double, double* %16
%264 = load double*, double** %24
%265 = load i32, i32* %31
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds double, double* %264, i64 %266
%268 = load double, double* %267
%269 = call double @llvm.fmuladd.f64(double %263, double %268, double %262)
%270 = load double*, double** %12
%271 = load i32, i32* %31
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %270, i64 %272
%274 = load double, double* %273
%275 = fadd double %274, %269
store double %275, double* %273
br label %276
276: ; preds = %241
%277 = load i32, i32* %31
%278 = add nsw i32 %277, 1
store i32 %278, i32* %31
br label %237
279: ; preds = %237
%280 = load i32, i32* %7
%281 = mul nsw i32 4, %280
%282 = load double*, double** %30
%283 = sext i32 %281 to i64
%284 = getelementptr inbounds double, double* %282, i64 %283
store double* %284, double** %30
br label %194
285: ; preds = %194
br label %286
286: ; preds = %318, %285
%287 = load i32, i32* %29
%288 = load i32, i32* %9
%289 = icmp slt i32 %287, %288
br i1 %289, label %290, label %323
290: ; preds = %286
%291 = load double*, double** %30
store double* %291, double** %21
%292 = load double*, double** %11
%293 = load i32, i32* %29
%294 = add nsw i32 %293, 1
store i32 %294, i32* %29
%295 = sext i32 %293 to i64
%296 = getelementptr inbounds double, double* %292, i64 %295
%297 = load double, double* %296
store double %297, double* %13
store i32 0, i32* %31
br label %298
298: ; preds = %315, %290
%299 = load i32, i32* %31
%300 = load i32, i32* %8
%301 = icmp slt i32 %299, %300
br i1 %301, label %302, label %318
302: ; preds = %298
%303 = load double, double* %13
%304 = load double*, double** %21
%305 = load i32, i32* %31
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double, double* %304, i64 %306
%308 = load double, double* %307
%309 = load double*, double** %12
%310 = load i32, i32* %31
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds double, double* %309, i64 %311
%313 = load double, double* %312
%314 = call double @llvm.fmuladd.f64(double %303, double %308, double %313)
store double %314, double* %312
br label %315
315: ; preds = %302
%316 = load i32, i32* %31
%317 = add nsw i32 %316, 1
store i32 %317, i32* %31
br label %298
318: ; preds = %298
%319 = load i32, i32* %7
%320 = load double*, double** %30
%321 = sext i32 %319 to i64
%322 = getelementptr inbounds double, double* %320, i64 %321
store double* %322, double** %30
br label %286
323: ; preds = %286
ret void
}

LLVM IR (-O2):
define void @dmatvec(i32 %0, i32 %1, i32 %2, double* nocapture %3, double* nocapture %4, double* nocapture %5) {
%7 = icmp sgt i32 %2, 7
br i1 %7, label %8, label %35
8: ; preds = %6
%9 = add nsw i32 %2, -7
%10 = sext i32 %0 to i64
%11 = icmp sgt i32 %1, 0
%12 = shl nsw i32 %0, 3
%13 = sext i32 %12 to i64
%14 = zext i32 %9 to i64
%15 = zext i32 %1 to i64
%16 = getelementptr double, double* %5, i64 %15
%17 = mul nsw i64 %10, 5
%18 = add nsw i64 %17, %15
%19 = shl nsw i64 %10, 2
%20 = add nsw i64 %19, %15
%21 = mul nsw i64 %10, 3
%22 = add nsw i64 %21, %15
%23 = shl nsw i64 %10, 1
%24 = add nsw i64 %23, %15
%25 = add nsw i64 %10, %15
%26 = mul nsw i64 %10, 6
%27 = add nsw i64 %26, %15
%28 = mul nsw i64 %10, 7
%29 = add nsw i64 %28, %15
%30 = icmp eq i32 %1, 1
%31 = and i64 %15, 4294967294
%32 = icmp eq i64 %31, %15
br label %57
33: ; preds = %248
%34 = trunc i64 %120 to i32
br label %35
35: ; preds = %33, %6
%36 = phi i32 [ 0, %6 ], [ %34, %33 ]
%37 = phi double* [ %3, %6 ], [ %249, %33 ]
%38 = add nsw i32 %2, -3
%39 = icmp slt i32 %36, %38
br i1 %39, label %40, label %254
40: ; preds = %35
%41 = sext i32 %0 to i64
%42 = icmp sgt i32 %1, 0
%43 = shl nsw i32 %0, 2
%44 = sext i32 %43 to i64
%45 = zext i32 %36 to i64
%46 = sext i32 %38 to i64
%47 = zext i32 %1 to i64
%48 = getelementptr double, double* %5, i64 %47
%49 = mul nsw i64 %41, 3
%50 = add nsw i64 %49, %47
%51 = shl nsw i64 %41, 1
%52 = add nsw i64 %51, %47
%53 = add nsw i64 %41, %47
%54 = icmp eq i32 %1, 1
%55 = and i64 %47, 4294967294
%56 = icmp eq i64 %55, %47
br label %278
57: ; preds = %8, %248
%58 = phi i64 [ 0, %8 ], [ %251, %248 ]
%59 = phi i64 [ 0, %8 ], [ %120, %248 ]
%60 = phi double* [ %3, %8 ], [ %249, %248 ]
%61 = mul i64 %58, %13
%62 = add i64 %17, %61
%63 = getelementptr double, double* %3, i64 %62
%64 = add i64 %18, %61
%65 = getelementptr double, double* %3, i64 %64
%66 = add i64 %19, %61
%67 = getelementptr double, double* %3, i64 %66
%68 = add i64 %20, %61
%69 = getelementptr double, double* %3, i64 %68
%70 = add i64 %21, %61
%71 = getelementptr double, double* %3, i64 %70
%72 = add i64 %22, %61
%73 = getelementptr double, double* %3, i64 %72
%74 = add i64 %23, %61
%75 = getelementptr double, double* %3, i64 %74
%76 = add i64 %24, %61
%77 = getelementptr double, double* %3, i64 %76
%78 = add i64 %61, %10
%79 = getelementptr double, double* %3, i64 %78
%80 = add i64 %25, %61
%81 = getelementptr double, double* %3, i64 %80
%82 = add i64 %61, %15
%83 = getelementptr double, double* %3, i64 %82
%84 = add i64 %26, %61
%85 = getelementptr double, double* %3, i64 %84
%86 = add i64 %27, %61
%87 = getelementptr double, double* %3, i64 %86
%88 = add i64 %28, %61
%89 = getelementptr double, double* %3, i64 %88
%90 = add i64 %29, %61
%91 = getelementptr double, double* %3, i64 %90
%92 = getelementptr inbounds double, double* %60, i64 %10
%93 = getelementptr inbounds double, double* %92, i64 %10
%94 = getelementptr inbounds double, double* %93, i64 %10
%95 = getelementptr inbounds double, double* %94, i64 %10
%96 = getelementptr inbounds double, double* %95, i64 %10
%97 = getelementptr inbounds double, double* %96, i64 %10
%98 = getelementptr inbounds double, double* %97, i64 %10
%99 = or i64 %59, 1
%100 = getelementptr inbounds double, double* %4, i64 %59
%101 = load double, double* %100
%102 = or i64 %59, 2
%103 = getelementptr inbounds double, double* %4, i64 %99
%104 = load double, double* %103
%105 = or i64 %59, 3
%106 = getelementptr inbounds double, double* %4, i64 %102
%107 = load double, double* %106
%108 = or i64 %59, 4
%109 = getelementptr inbounds double, double* %4, i64 %105
%110 = load double, double* %109
%111 = or i64 %59, 5
%112 = getelementptr inbounds double, double* %4, i64 %108
%113 = load double, double* %112
%114 = or i64 %59, 6
%115 = getelementptr inbounds double, double* %4, i64 %111
%116 = load double, double* %115
%117 = or i64 %59, 7
%118 = getelementptr inbounds double, double* %4, i64 %114
%119 = load double, double* %118
%120 = add nuw nsw i64 %59, 8
%121 = getelementptr inbounds double, double* %4, i64 %117
%122 = load double, double* %121
br i1 %11, label %123, label %248
123: ; preds = %57
br i1 %30, label %215, label %124
124: ; preds = %123
%125 = icmp ugt double* %65, %5
%126 = icmp ult double* %63, %16
%127 = and i1 %125, %126
%128 = icmp ugt double* %69, %5
%129 = icmp ult double* %67, %16
%130 = and i1 %128, %129
%131 = or i1 %127, %130
%132 = icmp ugt double* %73, %5
%133 = icmp ult double* %71, %16
%134 = and i1 %132, %133
%135 = or i1 %131, %134
%136 = icmp ugt double* %77, %5
%137 = icmp ult double* %75, %16
%138 = and i1 %136, %137
%139 = or i1 %135, %138
%140 = icmp ugt double* %81, %5
%141 = icmp ult double* %79, %16
%142 = and i1 %140, %141
%143 = or i1 %139, %142
%144 = icmp ugt double* %83, %5
%145 = icmp ult double* %60, %16
%146 = and i1 %144, %145
%147 = or i1 %143, %146
%148 = icmp ugt double* %87, %5
%149 = icmp ult double* %85, %16
%150 = and i1 %148, %149
%151 = or i1 %147, %150
%152 = icmp ugt double* %91, %5
%153 = icmp ult double* %89, %16
%154 = and i1 %152, %153
%155 = or i1 %151, %154
br i1 %155, label %215, label %156
156: ; preds = %124
%157 = insertelement <2 x double> poison, double %104, i64 0
%158 = shufflevector <2 x double> %157, <2 x double> poison, <2 x i32> zeroinitializer
%159 = insertelement <2 x double> poison, double %101, i64 0
%160 = shufflevector <2 x double> %159, <2 x double> poison, <2 x i32> zeroinitializer
%161 = insertelement <2 x double> poison, double %107, i64 0
%162 = shufflevector <2 x double> %161, <2 x double> poison, <2 x i32> zeroinitializer
%163 = insertelement <2 x double> poison, double %110, i64 0
%164 = shufflevector <2 x double> %163, <2 x double> poison, <2 x i32> zeroinitializer
%165 = insertelement <2 x double> poison, double %113, i64 0
%166 = shufflevector <2 x double> %165, <2 x double> poison, <2 x i32> zeroinitializer
%167 = insertelement <2 x double> poison, double %116, i64 0
%168 = shufflevector <2 x double> %167, <2 x double> poison, <2 x i32> zeroinitializer
%169 = insertelement <2 x double> poison, double %119, i64 0
%170 = shufflevector <2 x double> %169, <2 x double> poison, <2 x i32> zeroinitializer
%171 = insertelement <2 x double> poison, double %122, i64 0
%172 = shufflevector <2 x double> %171, <2 x double> poison, <2 x i32> zeroinitializer
br label %173
173: ; preds = %173, %156
%174 = phi i64 [ 0, %156 ], [ %212, %173 ]
%175 = getelementptr inbounds double, double* %60, i64 %174
%176 = bitcast double* %175 to <2 x double>*
%177 = load <2 x double>, <2 x double>* %176
%178 = getelementptr inbounds double, double* %92, i64 %174
%179 = bitcast double* %178 to <2 x double>*
%180 = load <2 x double>, <2 x double>* %179
%181 = fmul <2 x double> %158, %180
%182 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %160, <2 x double> %177, <2 x double> %181)
%183 = getelementptr inbounds double, double* %93, i64 %174
%184 = bitcast double* %183 to <2 x double>*
%185 = load <2 x double>, <2 x double>* %184
%186 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %162, <2 x double> %185, <2 x double> %182)
%187 = getelementptr inbounds double, double* %94, i64 %174
%188 = bitcast double* %187 to <2 x double>*
%189 = load <2 x double>, <2 x double>* %188
%190 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %164, <2 x double> %189, <2 x double> %186)
%191 = getelementptr inbounds double, double* %95, i64 %174
%192 = bitcast double* %191 to <2 x double>*
%193 = load <2 x double>, <2 x double>* %192
%194 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %166, <2 x double> %193, <2 x double> %190)
%195 = getelementptr inbounds double, double* %96, i64 %174
%196 = bitcast double* %195 to <2 x double>*
%197 = load <2 x double>, <2 x double>* %196
%198 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %168, <2 x double> %197, <2 x double> %194)
%199 = getelementptr inbounds double, double* %97, i64 %174
%200 = bitcast double* %199 to <2 x double>*
%201 = load <2 x double>, <2 x double>* %200
%202 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %170, <2 x double> %201, <2 x double> %198)
%203 = getelementptr inbounds double, double* %98, i64 %174
%204 = bitcast double* %203 to <2 x double>*
%205 = load <2 x double>, <2 x double>* %204
%206 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %172, <2 x double> %205, <2 x double> %202)
%207 = getelementptr inbounds double, double* %5, i64 %174
%208 = bitcast double* %207 to <2 x double>*
%209 = load <2 x double>, <2 x double>* %208
%210 = fadd <2 x double> %209, %206
%211 = bitcast double* %207 to <2 x double>*
store <2 x double> %210, <2 x double>* %211
%212 = add nuw i64 %174, 2
%213 = icmp eq i64 %212, %31
br i1 %213, label %214, label %173
214: ; preds = %173
br i1 %32, label %248, label %215
215: ; preds = %124, %123, %214
%216 = phi i64 [ 0, %124 ], [ 0, %123 ], [ %31, %214 ]
br label %217
217: ; preds = %215, %217
%218 = phi i64 [ %246, %217 ], [ %216, %215 ]
%219 = getelementptr inbounds double, double* %60, i64 %218
%220 = load double, double* %219
%221 = getelementptr inbounds double, double* %92, i64 %218
%222 = load double, double* %221
%223 = fmul double %104, %222
%224 = tail call double @llvm.fmuladd.f64(double %101, double %220, double %223)
%225 = getelementptr inbounds double, double* %93, i64 %218
%226 = load double, double* %225
%227 = tail call double @llvm.fmuladd.f64(double %107, double %226, double %224)
%228 = getelementptr inbounds double, double* %94, i64 %218
%229 = load double, double* %228
%230 = tail call double @llvm.fmuladd.f64(double %110, double %229, double %227)
%231 = getelementptr inbounds double, double* %95, i64 %218
%232 = load double, double* %231
%233 = tail call double @llvm.fmuladd.f64(double %113, double %232, double %230)
%234 = getelementptr inbounds double, double* %96, i64 %218
%235 = load double, double* %234
%236 = tail call double @llvm.fmuladd.f64(double %116, double %235, double %233)
%237 = getelementptr inbounds double, double* %97, i64 %218
%238 = load double, double* %237
%239 = tail call double @llvm.fmuladd.f64(double %119, double %238, double %236)
%240 = getelementptr inbounds double, double* %98, i64 %218
%241 = load double, double* %240
%242 = tail call double @llvm.fmuladd.f64(double %122, double %241, double %239)
%243 = getelementptr inbounds double, double* %5, i64 %218
%244 = load double, double* %243
%245 = fadd double %244, %242
store double %245, double* %243
%246 = add nuw nsw i64 %218, 1
%247 = icmp eq i64 %246, %15
br i1 %247, label %248, label %217
248: ; preds = %217, %214, %57
%249 = getelementptr inbounds double, double* %60, i64 %13
%250 = icmp ult i64 %120, %14
%251 = add i64 %58, 1
br i1 %250, label %57, label %33
252: ; preds = %388
%253 = trunc i64 %310 to i32
br label %254
254: ; preds = %252, %35
%255 = phi i32 [ %36, %35 ], [ %253, %252 ]
%256 = phi double* [ %37, %35 ], [ %389, %252 ]
%257 = icmp slt i32 %255, %2
br i1 %257, label %258, label %504
258: ; preds = %254
%259 = icmp sgt i32 %1, 0
%260 = sext i32 %0 to i64
%261 = zext i32 %255 to i64
%262 = zext i32 %1 to i64
%263 = getelementptr double, double* %5, i64 %262
%264 = and i64 %262, 4294967292
%265 = add nsw i64 %264, -4
%266 = lshr exact i64 %265, 2
%267 = add nuw nsw i64 %266, 1
%268 = icmp ult i32 %1, 4
%269 = and i64 %262, 4294967292
%270 = and i64 %267, 1
%271 = icmp eq i64 %265, 0
%272 = and i64 %267, 9223372036854775806
%273 = icmp eq i64 %270, 0
%274 = icmp eq i64 %269, %262
%275 = and i64 %262, 1
%276 = icmp eq i64 %275, 0
%277 = sub nsw i64 0, %262
br label %392
278: ; preds = %40, %388
%279 = phi i64 [ 0, %40 ], [ %391, %388 ]
%280 = phi i64 [ %45, %40 ], [ %310, %388 ]
%281 = phi double* [ %37, %40 ], [ %389, %388 ]
%282 = mul i64 %279, %44
%283 = add i64 %49, %282
%284 = getelementptr double, double* %37, i64 %283
%285 = add i64 %50, %282
%286 = getelementptr double, double* %37, i64 %285
%287 = add i64 %51, %282
%288 = getelementptr double, double* %37, i64 %287
%289 = add i64 %52, %282
%290 = getelementptr double, double* %37, i64 %289
%291 = add i64 %282, %41
%292 = getelementptr double, double* %37, i64 %291
%293 = add i64 %53, %282
%294 = getelementptr double, double* %37, i64 %293
%295 = add i64 %282, %47
%296 = getelementptr double, double* %37, i64 %295
%297 = getelementptr inbounds double, double* %281, i64 %41
%298 = getelementptr inbounds double, double* %297, i64 %41
%299 = getelementptr inbounds double, double* %298, i64 %41
%300 = getelementptr inbounds double, double* %4, i64 %280
%301 = load double, double* %300
%302 = and i64 %280, 4294967294
%303 = or i64 %302, 1
%304 = getelementptr inbounds double, double* %4, i64 %303
%305 = load double, double* %304
%306 = and i64 %280, 4294967293
%307 = or i64 %306, 2
%308 = getelementptr inbounds double, double* %4, i64 %307
%309 = load double, double* %308
%310 = add nuw nsw i64 %280, 4
%311 = and i64 %280, 4294967292
%312 = or i64 %311, 3
%313 = getelementptr inbounds double, double* %4, i64 %312
%314 = load double, double* %313
br i1 %42, label %315, label %388
315: ; preds = %278
br i1 %54, label %367, label %316
316: ; preds = %315
%317 = icmp ugt double* %286, %5
%318 = icmp ult double* %284, %48
%319 = and i1 %317, %318
%320 = icmp ugt double* %290, %5
%321 = icmp ult double* %288, %48
%322 = and i1 %320, %321
%323 = or i1 %319, %322
%324 = icmp ugt double* %294, %5
%325 = icmp ult double* %292, %48
%326 = and i1 %324, %325
%327 = or i1 %323, %326
%328 = icmp ugt double* %296, %5
%329 = icmp ult double* %281, %48
%330 = and i1 %328, %329
%331 = or i1 %327, %330
br i1 %331, label %367, label %332
332: ; preds = %316
%333 = insertelement <2 x double> poison, double %305, i64 0
%334 = shufflevector <2 x double> %333, <2 x double> poison, <2 x i32> zeroinitializer
%335 = insertelement <2 x double> poison, double %301, i64 0
%336 = shufflevector <2 x double> %335, <2 x double> poison, <2 x i32> zeroinitializer
%337 = insertelement <2 x double> poison, double %309, i64 0
%338 = shufflevector <2 x double> %337, <2 x double> poison, <2 x i32> zeroinitializer
%339 = insertelement <2 x double> poison, double %314, i64 0
%340 = shufflevector <2 x double> %339, <2 x double> poison, <2 x i32> zeroinitializer
br label %341
341: ; preds = %341, %332
%342 = phi i64 [ 0, %332 ], [ %364, %341 ]
%343 = getelementptr inbounds double, double* %281, i64 %342
%344 = bitcast double* %343 to <2 x double>*
%345 = load <2 x double>, <2 x double>* %344
%346 = getelementptr inbounds double, double* %297, i64 %342
%347 = bitcast double* %346 to <2 x double>*
%348 = load <2 x double>, <2 x double>* %347
%349 = fmul <2 x double> %334, %348
%350 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %336, <2 x double> %345, <2 x double> %349)
%351 = getelementptr inbounds double, double* %298, i64 %342
%352 = bitcast double* %351 to <2 x double>*
%353 = load <2 x double>, <2 x double>* %352
%354 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %338, <2 x double> %353, <2 x double> %350)
%355 = getelementptr inbounds double, double* %299, i64 %342
%356 = bitcast double* %355 to <2 x double>*
%357 = load <2 x double>, <2 x double>* %356
%358 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %340, <2 x double> %357, <2 x double> %354)
%359 = getelementptr inbounds double, double* %5, i64 %342
%360 = bitcast double* %359 to <2 x double>*
%361 = load <2 x double>, <2 x double>* %360
%362 = fadd <2 x double> %361, %358
%363 = bitcast double* %359 to <2 x double>*
store <2 x double> %362, <2 x double>* %363
%364 = add nuw i64 %342, 2
%365 = icmp eq i64 %364, %55
br i1 %365, label %366, label %341
366: ; preds = %341
br i1 %56, label %388, label %367
367: ; preds = %316, %315, %366
%368 = phi i64 [ 0, %316 ], [ 0, %315 ], [ %55, %366 ]
br label %369
369: ; preds = %367, %369
%370 = phi i64 [ %386, %369 ], [ %368, %367 ]
%371 = getelementptr inbounds double, double* %281, i64 %370
%372 = load double, double* %371
%373 = getelementptr inbounds double, double* %297, i64 %370
%374 = load double, double* %373
%375 = fmul double %305, %374
%376 = tail call double @llvm.fmuladd.f64(double %301, double %372, double %375)
%377 = getelementptr inbounds double, double* %298, i64 %370
%378 = load double, double* %377
%379 = tail call double @llvm.fmuladd.f64(double %309, double %378, double %376)
%380 = getelementptr inbounds double, double* %299, i64 %370
%381 = load double, double* %380
%382 = tail call double @llvm.fmuladd.f64(double %314, double %381, double %379)
%383 = getelementptr inbounds double, double* %5, i64 %370
%384 = load double, double* %383
%385 = fadd double %384, %382
store double %385, double* %383
%386 = add nuw nsw i64 %370, 1
%387 = icmp eq i64 %386, %47
br i1 %387, label %388, label %369
388: ; preds = %369, %366, %278
%389 = getelementptr inbounds double, double* %281, i64 %44
%390 = icmp slt i64 %310, %46
%391 = add i64 %279, 1
br i1 %390, label %278, label %252
392: ; preds = %258, %499
%393 = phi i64 [ 0, %258 ], [ %503, %499 ]
%394 = phi i64 [ %261, %258 ], [ %399, %499 ]
%395 = phi double* [ %256, %258 ], [ %500, %499 ]
%396 = mul i64 %393, %260
%397 = add i64 %396, %262
%398 = getelementptr double, double* %256, i64 %397
%399 = add nuw nsw i64 %394, 1
%400 = getelementptr inbounds double, double* %4, i64 %394
%401 = load double, double* %400
br i1 %259, label %402, label %499
402: ; preds = %392
br i1 %268, label %471, label %403
403: ; preds = %402
%404 = icmp ugt double* %398, %5
%405 = icmp ult double* %395, %263
%406 = and i1 %404, %405
br i1 %406, label %471, label %407
407: ; preds = %403
%408 = insertelement <2 x double> poison, double %401, i64 0
%409 = shufflevector <2 x double> %408, <2 x double> poison, <2 x i32> zeroinitializer
%410 = insertelement <2 x double> poison, double %401, i64 0
%411 = shufflevector <2 x double> %410, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %271, label %451, label %412
412: ; preds = %407, %412
%413 = phi i64 [ %448, %412 ], [ 0, %407 ]
%414 = phi i64 [ %449, %412 ], [ 0, %407 ]
%415 = getelementptr inbounds double, double* %395, i64 %413
%416 = bitcast double* %415 to <2 x double>*
%417 = load <2 x double>, <2 x double>* %416
%418 = getelementptr inbounds double, double* %415, i64 2
%419 = bitcast double* %418 to <2 x double>*
%420 = load <2 x double>, <2 x double>* %419
%421 = getelementptr inbounds double, double* %5, i64 %413
%422 = bitcast double* %421 to <2 x double>*
%423 = load <2 x double>, <2 x double>* %422
%424 = getelementptr inbounds double, double* %421, i64 2
%425 = bitcast double* %424 to <2 x double>*
%426 = load <2 x double>, <2 x double>* %425
%427 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %409, <2 x double> %417, <2 x double> %423)
%428 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %411, <2 x double> %420, <2 x double> %426)
%429 = bitcast double* %421 to <2 x double>*
store <2 x double> %427, <2 x double>* %429
%430 = bitcast double* %424 to <2 x double>*
store <2 x double> %428, <2 x double>* %430
%431 = or i64 %413, 4
%432 = getelementptr inbounds double, double* %395, i64 %431
%433 = bitcast double* %432 to <2 x double>*
%434 = load <2 x double>, <2 x double>* %433
%435 = getelementptr inbounds double, double* %432, i64 2
%436 = bitcast double* %435 to <2 x double>*
%437 = load <2 x double>, <2 x double>* %436
%438 = getelementptr inbounds double, double* %5, i64 %431
%439 = bitcast double* %438 to <2 x double>*
%440 = load <2 x double>, <2 x double>* %439
%441 = getelementptr inbounds double, double* %438, i64 2
%442 = bitcast double* %441 to <2 x double>*
%443 = load <2 x double>, <2 x double>* %442
%444 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %409, <2 x double> %434, <2 x double> %440)
%445 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %411, <2 x double> %437, <2 x double> %443)
%446 = bitcast double* %438 to <2 x double>*
store <2 x double> %444, <2 x double>* %446
%447 = bitcast double* %441 to <2 x double>*
store <2 x double> %445, <2 x double>* %447
%448 = add nuw i64 %413, 8
%449 = add i64 %414, 2
%450 = icmp eq i64 %449, %272
br i1 %450, label %451, label %412
451: ; preds = %412, %407
%452 = phi i64 [ 0, %407 ], [ %448, %412 ]
br i1 %273, label %470, label %453
453: ; preds = %451
%454 = getelementptr inbounds double, double* %395, i64 %452
%455 = bitcast double* %454 to <2 x double>*
%456 = load <2 x double>, <2 x double>* %455
%457 = getelementptr inbounds double, double* %454, i64 2
%458 = bitcast double* %457 to <2 x double>*
%459 = load <2 x double>, <2 x double>* %458
%460 = getelementptr inbounds double, double* %5, i64 %452
%461 = bitcast double* %460 to <2 x double>*
%462 = load <2 x double>, <2 x double>* %461
%463 = getelementptr inbounds double, double* %460, i64 2
%464 = bitcast double* %463 to <2 x double>*
%465 = load <2 x double>, <2 x double>* %464
%466 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %409, <2 x double> %456, <2 x double> %462)
%467 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %411, <2 x double> %459, <2 x double> %465)
%468 = bitcast double* %460 to <2 x double>*
store <2 x double> %466, <2 x double>* %468
%469 = bitcast double* %463 to <2 x double>*
store <2 x double> %467, <2 x double>* %469
br label %470
470: ; preds = %451, %453
br i1 %274, label %499, label %471
471: ; preds = %403, %402, %470
%472 = phi i64 [ 0, %403 ], [ 0, %402 ], [ %269, %470 ]
%473 = xor i64 %472, -1
br i1 %276, label %481, label %474
474: ; preds = %471
%475 = getelementptr inbounds double, double* %395, i64 %472
%476 = load double, double* %475
%477 = getelementptr inbounds double, double* %5, i64 %472
%478 = load double, double* %477
%479 = tail call double @llvm.fmuladd.f64(double %401, double %476, double %478)
store double %479, double* %477
%480 = or i64 %472, 1
br label %481
481: ; preds = %474, %471
%482 = phi i64 [ %472, %471 ], [ %480, %474 ]
%483 = icmp eq i64 %473, %277
br i1 %483, label %499, label %484
484: ; preds = %481, %484
%485 = phi i64 [ %497, %484 ], [ %482, %481 ]
%486 = getelementptr inbounds double, double* %395, i64 %485
%487 = load double, double* %486
%488 = getelementptr inbounds double, double* %5, i64 %485
%489 = load double, double* %488
%490 = tail call double @llvm.fmuladd.f64(double %401, double %487, double %489)
store double %490, double* %488
%491 = add nuw nsw i64 %485, 1
%492 = getelementptr inbounds double, double* %395, i64 %491
%493 = load double, double* %492
%494 = getelementptr inbounds double, double* %5, i64 %491
%495 = load double, double* %494
%496 = tail call double @llvm.fmuladd.f64(double %401, double %493, double %495)
store double %496, double* %494
%497 = add nuw nsw i64 %485, 2
%498 = icmp eq i64 %497, %262
br i1 %498, label %499, label %484
499: ; preds = %481, %484, %470, %392
%500 = getelementptr inbounds double, double* %395, i64 %260
%501 = trunc i64 %399 to i32
%502 = icmp slt i32 %501, %2
%503 = add i64 %393, 1
br i1 %502, label %392, label %504
504: ; preds = %499, %254
ret void
}