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


x86 assembly (clang, -O0):
<smatvec>:
push   %rbp
mov    %rsp,%rbp
sub    $0x38,%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,-0xb4(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    147c <smatvec+0x37c>
mov    -0x70(%rbp),%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    -0xa8(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    145f <smatvec+0x35f>
movsd  -0x30(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x38(%rbp),%xmm1
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x88(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x98(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0xa0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xa0(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xa8(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xb0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xb0(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    130b <smatvec+0x20b>
mov    -0x4(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    112f <smatvec+0x2f>
jmp    1481 <smatvec+0x381>
mov    -0xb4(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    164a <smatvec+0x54a>
mov    -0x70(%rbp),%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    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    162d <smatvec+0x52d>
movsd  -0x30(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
movsd  -0x38(%rbp),%xmm1
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x80(%rbp)
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm1
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x88(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1571 <smatvec+0x471>
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    1481 <smatvec+0x381>
jmp    164f <smatvec+0x54f>
mov    -0xb4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1704 <smatvec+0x604>
mov    -0x70(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16ea <smatvec+0x5ea>
movsd  -0x30(%rbp),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x78(%rbp)
movsd  (%rax),%xmm2
mov    -0x28(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1692 <smatvec+0x592>
mov    -0x4(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    164f <smatvec+0x54f>
add    $0x38,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<smatvec>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r8,0x60(%rsp)
mov    %rcx,%r11
xor    %ebx,%ebx
movslq %edi,%rax
mov    %esi,-0x54(%rsp)
mov    %esi,%r10d
cmp    $0x8,%edx
mov    %rdx,0x58(%rsp)
mov    %rax,-0x78(%rsp)
mov    %r10,-0x50(%rsp)
jl     1810 <smatvec+0x710>
lea    -0x7(%rdx),%ecx
mov    %rcx,0x50(%rsp)
lea    0x0(,%rax,8),%ecx
movslq %ecx,%rcx
lea    (%r9,%r10,8),%rdx
mov    %rdx,0xd8(%rsp)
lea    (%rax,%rax,1),%rdx
mov    %rdx,0xd0(%rsp)
lea    (%rdx,%rdx,2),%rdx
mov    %rdx,0xc8(%rsp)
add    %r10,%rdx
mov    %rdx,0xc0(%rsp)
lea    (%rax,%rax,4),%rdx
mov    %rdx,0xb8(%rsp)
lea    (%rdx,%r10,1),%rdx
mov    %rdx,0xb0(%rsp)
lea    0x0(,%rax,4),%rdx
mov    %rdx,0xa8(%rsp)
lea    (%r10,%rax,4),%rdx
mov    %rdx,0xa0(%rsp)
lea    (%rax,%rax,2),%rdx
mov    %rdx,0x98(%rsp)
add    %r10,%rdx
mov    %rdx,0x90(%rsp)
lea    0x0(,%rax,8),%r14
mov    %r14,%rdx
sub    %rax,%rdx
mov    %r10d,%esi
and    $0xfffffffe,%esi
mov    %rsi,0x68(%rsp)
lea    (%r10,%rax,2),%rsi
mov    %rsi,0x80(%rsp)
lea    (%rax,%r10,1),%rsi
mov    %rsi,0x78(%rsp)
mov    %rdx,0x88(%rsp)
add    %r10,%rdx
mov    %rdx,0x70(%rsp)
mov    %rcx,0xe0(%rsp)
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
xor    %ebp,%ebp
mov    %r11,-0x30(%rsp)
xor    %ebx,%ebx
jmp    124e <smatvec+0x14e>
nopw   0x0(%rax,%rax,1)
mov    -0x60(%rsp),%r11
add    0x48(%rsp),%r11
add    $0x1,%rbp
mov    -0x40(%rsp),%rbx
cmp    0x50(%rsp),%rbx
jae    1806 <smatvec+0x706>
mov    %r11,-0x60(%rsp)
lea    0x8(%rbx),%rdx
mov    %rdx,-0x40(%rsp)
cmpl   $0x0,-0x54(%rsp)
jle    1230 <smatvec+0x130>
mov    %rbx,%rcx
mov    %rbp,-0x68(%rsp)
lea    0x0(,%rbx,8),%rdi
mov    %rdi,%r8
or     $0x8,%r8
mov    %rdi,%r10
or     $0x10,%r10
mov    %rdi,%r11
or     $0x18,%r11
mov    %rdi,%rbx
or     $0x20,%rbx
mov    %rdi,%rax
or     $0x28,%rax
mov    0x60(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm11
mov    %rdi,%rcx
or     $0x30,%rcx
or     $0x38,%rdi
movsd  (%rdx,%r8,1),%xmm10
mov    -0x78(%rsp),%rsi
mov    -0x60(%rsp),%r8
lea    (%r8,%rsi,8),%rbp
movsd  (%rdx,%r10,1),%xmm2
mov    -0x78(%rsp),%rsi
mov    %rbp,-0x10(%rsp)
lea    0x0(%rbp,%rsi,8),%rbp
movsd  (%rdx,%r11,1),%xmm3
mov    -0x78(%rsp),%rsi
mov    %rbp,0x20(%rsp)
lea    0x0(%rbp,%rsi,8),%r13
movsd  (%rdx,%rbx,1),%xmm12
mov    -0x78(%rsp),%rsi
lea    0x0(%r13,%rsi,8),%r12
movsd  (%rdx,%rax,1),%xmm13
mov    -0x78(%rsp),%rax
lea    (%r12,%rax,8),%r11
movsd  (%rdx,%rcx,1),%xmm14
lea    (%r11,%rax,8),%r10
movsd  (%rdx,%rdi,1),%xmm15
lea    (%r10,%rax,8),%rbx
cmpl   $0x1,-0x54(%rsp)
jne    1340 <smatvec+0x240>
xor    %edi,%edi
mov    %r8,%rcx
mov    -0x68(%rsp),%rbp
mov    -0x10(%rsp),%rdx
mov    0x20(%rsp),%r15
jmp    1730 <smatvec+0x630>
nopl   (%rax)
mov    %rbx,-0x48(%rsp)
mov    -0x68(%rsp),%rcx
imul   0xe0(%rsp),%rcx
mov    0xc8(%rsp),%rdx
lea    (%rdx,%rcx,1),%r15
mov    0xc0(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdi
mov    0xb8(%rsp),%rdx
add    %rcx,%rdx
mov    %rdx,0x38(%rsp)
mov    0xb0(%rsp),%rdx
mov    %r8,%rbx
lea    (%rdx,%rcx,1),%r8
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdx
mov    %rdx,0x40(%rsp)
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rcx,1),%rbp
mov    0x98(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdx
mov    %rdx,-0x20(%rsp)
mov    0x90(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdx
mov    %rdx,0xf0(%rsp)
mov    0xd0(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdx
mov    %rdx,-0x18(%rsp)
mov    0x80(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdx
mov    %rdx,-0x28(%rsp)
lea    (%rcx,%rax,1),%rax
mov    %rax,0x10(%rsp)
mov    0x78(%rsp),%rax
add    %rcx,%rax
mov    %rax,-0x38(%rsp)
mov    -0x50(%rsp),%rax
add    %rcx,%rax
mov    %rax,(%rsp)
mov    0x88(%rsp),%rax
add    %rcx,%rax
mov    %rax,0xe8(%rsp)
add    0x70(%rsp),%rcx
mov    -0x30(%rsp),%rdx
lea    (%rdx,%rdi,8),%rax
cmp    %r9,%rax
seta   -0x69(%rsp)
lea    (%rdx,%r15,8),%rax
mov    0xd8(%rsp),%r15
cmp    %r15,%rax
lea    (%rdx,%r8,8),%rax
setb   -0x6a(%rsp)
cmp    %r9,%rax
mov    0x38(%rsp),%rax
lea    (%rdx,%rax,8),%rax
seta   %dil
cmp    %r15,%rax
lea    (%rdx,%rbp,8),%rax
setb   0x38(%rsp)
cmp    %r9,%rax
mov    0x40(%rsp),%rax
lea    (%rdx,%rax,8),%rax
seta   %r8b
cmp    %r15,%rax
mov    0xf0(%rsp),%rax
lea    (%rdx,%rax,8),%rax
setb   0x40(%rsp)
cmp    %r9,%rax
mov    -0x20(%rsp),%rax
lea    (%rdx,%rax,8),%rax
seta   %bpl
cmp    %r15,%rax
mov    -0x28(%rsp),%rax
lea    (%rdx,%rax,8),%rax
setb   -0x20(%rsp)
cmp    %r9,%rax
seta   -0x28(%rsp)
mov    -0x18(%rsp),%rax
lea    (%rdx,%rax,8),%rax
cmp    %r15,%rax
mov    -0x38(%rsp),%rax
lea    (%rdx,%rax,8),%rax
setb   -0x18(%rsp)
cmp    %r9,%rax
mov    0x10(%rsp),%rax
lea    (%rdx,%rax,8),%rax
seta   0x10(%rsp)
cmp    %r15,%rax
mov    (%rsp),%rax
lea    (%rdx,%rax,8),%rax
lea    (%rdx,%rcx,8),%rcx
setb   (%rsp)
cmp    %r9,%rax
seta   %sil
cmp    %r15,%rbx
setb   -0x38(%rsp)
cmp    %r9,%rcx
seta   %bl
mov    0xe8(%rsp),%rax
lea    (%rdx,%rax,8),%rcx
cmp    %r15,%rcx
setb   %al
mov    -0x6a(%rsp),%cl
test   %cl,-0x69(%rsp)
jne    17e1 <smatvec+0x6e1>
mov    %ebx,%ecx
and    0x38(%rsp),%dil
mov    -0x10(%rsp),%rdx
mov    -0x48(%rsp),%rbx
mov    0x20(%rsp),%r15
jne    171b <smatvec+0x61b>
and    0x40(%rsp),%r8b
jne    171b <smatvec+0x61b>
and    -0x20(%rsp),%bpl
jne    171b <smatvec+0x61b>
mov    %eax,%edi
mov    -0x18(%rsp),%al
and    %al,-0x28(%rsp)
jne    171b <smatvec+0x61b>
mov    (%rsp),%al
and    %al,0x10(%rsp)
jne    171b <smatvec+0x61b>
and    -0x38(%rsp),%sil
mov    -0x60(%rsp),%rbx
mov    -0x68(%rsp),%rbp
jne    170a <smatvec+0x60a>
and    %dil,%cl
jne    170a <smatvec+0x60a>
mov    %rdx,%r8
mov    0x68(%rsp),%rdx
mov    -0x48(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    %rax,-0x48(%rsp)
lea    (%r10,%rdx,8),%r10
lea    (%r11,%rdx,8),%r11
lea    (%r12,%rdx,8),%r12
lea    0x0(%r13,%rdx,8),%r13
lea    (%r15,%rdx,8),%r15
lea    (%r8,%rdx,8),%r8
lea    (%rbx,%rdx,8),%rcx
movapd %xmm10,0x20(%rsp)
unpcklpd %xmm10,%xmm10
movapd %xmm11,-0x10(%rsp)
unpcklpd %xmm11,%xmm11
movapd %xmm2,0x10(%rsp)
unpcklpd %xmm2,%xmm2
movapd %xmm3,(%rsp)
unpcklpd %xmm3,%xmm3
movapd %xmm12,%xmm4
unpcklpd %xmm12,%xmm4
movapd %xmm13,%xmm5
unpcklpd %xmm13,%xmm5
movapd %xmm14,%xmm6
unpcklpd %xmm14,%xmm6
movapd %xmm15,%xmm7
unpcklpd %xmm15,%xmm7
xor    %edi,%edi
mov    -0x78(%rsp),%rax
nopw   0x0(%rax,%rax,1)
lea    (%rbx,%rdi,8),%rbp
movupd (%rbx,%rdi,8),%xmm8
mulpd  %xmm11,%xmm8
movupd 0x0(%rbp,%rax,8),%xmm9
add    %r14,%rbp
mulpd  %xmm10,%xmm9
addpd  %xmm8,%xmm9
movupd 0x0(%rbp,%rax,8),%xmm1
add    %r14,%rbp
mulpd  %xmm2,%xmm1
addpd  %xmm9,%xmm1
movupd 0x0(%rbp,%rax,8),%xmm0
add    %r14,%rbp
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd 0x0(%rbp,%rax,8),%xmm1
add    %r14,%rbp
mulpd  %xmm4,%xmm1
addpd  %xmm0,%xmm1
movupd 0x0(%rbp,%rax,8),%xmm0
add    %r14,%rbp
mulpd  %xmm5,%xmm0
addpd  %xmm1,%xmm0
movupd 0x0(%rbp,%rax,8),%xmm1
add    %r14,%rbp
mulpd  %xmm6,%xmm1
addpd  %xmm0,%xmm1
movupd 0x0(%rbp,%rax,8),%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
movupd (%r9,%rdi,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%r9,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    1630 <smatvec+0x530>
mov    %rdx,%rdi
cmp    -0x50(%rsp),%rdx
mov    -0x68(%rsp),%rbp
movapd -0x10(%rsp),%xmm11
movapd 0x20(%rsp),%xmm10
movapd 0x10(%rsp),%xmm2
mov    %r8,%rdx
movapd (%rsp),%xmm3
mov    -0x48(%rsp),%rbx
je     1230 <smatvec+0x130>
jmp    1730 <smatvec+0x630>
xor    %edi,%edi
mov    %rbx,%rcx
mov    -0x78(%rsp),%rax
mov    -0x48(%rsp),%rbx
jmp    1730 <smatvec+0x630>
xor    %edi,%edi
mov    -0x60(%rsp),%rcx
mov    -0x78(%rsp),%rax
mov    -0x68(%rsp),%rbp
nopl   0x0(%rax)
mov    %r15,%r8
mov    %rdi,%rsi
lea    (%r9,%rdi,8),%rdi
mov    -0x50(%rsp),%r15
sub    %rsi,%r15
mov    %r8,%rsi
xor    %r8d,%r8d
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%r8,8),%xmm0
mulsd  %xmm10,%xmm0
movsd  (%rcx,%r8,8),%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rsi,%r8,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x0(%r13,%r8,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r12,%r8,8),%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r11,%r8,8),%xmm1
mulsd  %xmm13,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r10,%r8,8),%xmm0
mulsd  %xmm14,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rbx,%r8,8),%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm0,%xmm1
addsd  (%rdi,%r8,8),%xmm1
movsd  %xmm1,(%rdi,%r8,8)
add    $0x1,%r8
cmp    %r8,%r15
jne    1750 <smatvec+0x650>
jmp    1230 <smatvec+0x130>
xor    %edi,%edi
mov    -0x60(%rsp),%rcx
mov    -0x78(%rsp),%rax
mov    -0x68(%rsp),%rbp
mov    -0x10(%rsp),%rdx
mov    -0x48(%rsp),%rbx
mov    0x20(%rsp),%r15
jmp    1730 <smatvec+0x630>
mov    0x58(%rsp),%rdx
mov    -0x50(%rsp),%r10
lea    -0x3(%rdx),%ecx
cmp    %ecx,%ebx
mov    %r11,-0x30(%rsp)
jge    1b65 <smatvec+0xa65>
lea    0x0(,%rax,4),%edx
movslq %edx,%rdx
mov    %ebx,%ebx
movslq %ecx,%r14
lea    (%r9,%r10,8),%rcx
mov    %rcx,-0x48(%rsp)
lea    (%rax,%rax,2),%rcx
mov    %rcx,0x50(%rsp)
add    %r10,%rcx
mov    %rcx,0x48(%rsp)
lea    (%rax,%rax,1),%rcx
mov    %rcx,0x10(%rsp)
lea    (%r10,%rax,2),%rcx
mov    %rcx,(%rsp)
lea    (%rax,%r10,1),%rcx
mov    %rcx,-0x18(%rsp)
and    $0xfffffffe,%r10d
mov    %rdx,0x20(%rsp)
lea    0x0(,%rdx,8),%r8
mov    %rax,%rcx
shl    $0x4,%rcx
mov    %rcx,-0x20(%rsp)
lea    0x0(,%rax,8),%rcx
lea    (%rcx,%rcx,2),%rcx
mov    %rcx,-0x28(%rsp)
xor    %r15d,%r15d
mov    %r14,-0x38(%rsp)
mov    %r8,-0x10(%rsp)
jmp    18b0 <smatvec+0x7b0>
add    %r8,%r11
add    $0x1,%r15
cmp    %r14,%rbx
jge    1b5b <smatvec+0xa5b>
mov    %rbx,%rcx
add    $0x4,%rbx
cmpl   $0x0,-0x54(%rsp)
jle    18a0 <smatvec+0x7a0>
mov    %ecx,%eax
shl    $0x3,%rax
mov    %rax,%rdx
or     $0x8,%rdx
mov    %rax,%rsi
or     $0x10,%rsi
or     $0x18,%rax
mov    -0x78(%rsp),%rdi
lea    (%r11,%rdi,8),%r12
mov    -0x78(%rsp),%rdi
lea    (%r12,%rdi,8),%r13
mov    0x60(%rsp),%rdi
movsd  (%rdi,%rcx,8),%xmm0
movsd  (%rdi,%rdx,1),%xmm1
movsd  (%rdi,%rsi,1),%xmm2
movsd  (%rdi,%rax,1),%xmm3
mov    -0x78(%rsp),%rax
lea    0x0(,%rax,8),%rdi
add    %r13,%rdi
cmpl   $0x1,-0x54(%rsp)
jne    1930 <smatvec+0x830>
xor    %ebp,%ebp
mov    %r11,%rdx
jmp    1b00 <smatvec+0xa00>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,-0x40(%rsp)
mov    %rax,%rsi
mov    %r15,%rax
imul   0x20(%rsp),%rax
mov    0x50(%rsp),%rcx
add    %rax,%rcx
mov    0x48(%rsp),%rdx
add    %rax,%rdx
mov    0x10(%rsp),%rbp
lea    0x0(%rbp,%rax,1),%r8
mov    (%rsp),%rbx
lea    (%rbx,%rax,1),%rbp
add    %rax,%rsi
mov    %rsi,-0x60(%rsp)
mov    -0x18(%rsp),%rsi
add    %rax,%rsi
add    -0x50(%rsp),%rax
mov    -0x30(%rsp),%r14
lea    (%r14,%rdx,8),%rdx
cmp    %r9,%rdx
lea    (%r14,%rcx,8),%rcx
seta   -0x68(%rsp)
mov    -0x48(%rsp),%rbx
cmp    %rbx,%rcx
lea    (%r14,%rbp,8),%rcx
setb   %bpl
cmp    %r9,%rcx
lea    (%r14,%r8,8),%rdx
seta   %cl
cmp    %rbx,%rdx
lea    (%r14,%rsi,8),%rdx
setb   %r8b
cmp    %r9,%rdx
mov    -0x60(%rsp),%rdx
lea    (%r14,%rdx,8),%rsi
seta   %dl
cmp    %rbx,%rsi
lea    (%r14,%rax,8),%rsi
setb   %al
cmp    %r9,%rsi
seta   %sil
cmp    %rbx,%r11
setb   %bl
test   %bpl,-0x68(%rsp)
jne    1ad8 <smatvec+0x9d8>
and    %r8b,%cl
jne    1ad8 <smatvec+0x9d8>
mov    %ebx,%ecx
and    %al,%dl
mov    -0x40(%rsp),%rbx
mov    -0x38(%rsp),%r14
mov    -0x10(%rsp),%r8
jne    1acc <smatvec+0x9cc>
and    %cl,%sil
jne    1acc <smatvec+0x9cc>
lea    (%rdi,%r10,8),%rdi
lea    0x0(%r13,%r10,8),%r13
lea    (%r12,%r10,8),%r12
lea    (%r11,%r10,8),%rdx
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    %r11,%rbp
xor    %r8d,%r8d
mov    -0x78(%rsp),%rax
mov    -0x20(%rsp),%rcx
mov    -0x28(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp),%xmm4
mulpd  %xmm9,%xmm4
movupd 0x0(%rbp,%rax,8),%xmm5
mulpd  %xmm8,%xmm5
addpd  %xmm4,%xmm5
movupd 0x0(%rbp,%rcx,1),%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
movupd 0x0(%rbp,%rsi,1),%xmm5
mulpd  %xmm7,%xmm5
addpd  %xmm4,%xmm5
movupd (%r9,%r8,8),%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%r9,%r8,8)
add    $0x2,%r8
add    $0x10,%rbp
cmp    %r8,%r10
jne    1a60 <smatvec+0x960>
mov    %r10,%rbp
cmp    -0x50(%rsp),%r10
mov    -0x40(%rsp),%rbx
mov    -0x10(%rsp),%r8
je     18a0 <smatvec+0x7a0>
jmp    1b00 <smatvec+0xa00>
xor    %ebp,%ebp
mov    %r11,%rdx
mov    -0x78(%rsp),%rax
jmp    1b00 <smatvec+0xa00>
xor    %ebp,%ebp
mov    %r11,%rdx
mov    -0x78(%rsp),%rax
mov    -0x40(%rsp),%rbx
mov    -0x38(%rsp),%r14
mov    -0x10(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r9,%rbp,8),%rsi
mov    -0x50(%rsp),%rcx
sub    %rbp,%rcx
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  (%r12,%rbp,8),%xmm4
mulsd  %xmm1,%xmm4
movsd  (%rdx,%rbp,8),%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
movsd  0x0(%r13,%rbp,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  (%rdi,%rbp,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
addsd  (%rsi,%rbp,8),%xmm5
movsd  %xmm5,(%rsi,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rcx
jne    1b10 <smatvec+0xa10>
jmp    18a0 <smatvec+0x7a0>
mov    %r11,-0x30(%rsp)
mov    0x58(%rsp),%rdx
cmp    %edx,%ebx
jge    1dce <smatvec+0xcce>
mov    %ebx,%edx
mov    -0x50(%rsp),%r13
lea    (%r9,%r13,8),%rcx
mov    %rcx,-0x60(%rsp)
mov    %r13d,%r8d
and    $0xfffffffc,%r8d
lea    -0x4(%r8),%r12
mov    %r12,-0x40(%rsp)
shr    $0x2,%r12
add    $0x1,%r12
mov    %r12,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x68(%rsp)
neg    %r13
lea    0x0(,%rax,8),%r14
lea    0x8(%r9),%r15
xor    %ecx,%ecx
mov    -0x30(%rsp),%rsi
jmp    1bd1 <smatvec+0xad1>
nopl   0x0(%rax)
add    %r14,%rsi
add    $0x1,%rcx
cmp    0x58(%rsp),%edx
jge    1dce <smatvec+0xcce>
mov    %rdx,%rdi
add    $0x1,%rdx
cmpl   $0x0,-0x54(%rsp)
jle    1bc0 <smatvec+0xac0>
mov    0x60(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm0
cmpl   $0x4,-0x54(%rsp)
jae    1c00 <smatvec+0xb00>
xor    %ebx,%ebx
mov    %rsi,%rdi
jmp    1d50 <smatvec+0xc50>
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rax
imul   -0x78(%rsp),%rax
mov    -0x50(%rsp),%rbp
add    %rbp,%rax
mov    -0x30(%rsp),%rdi
lea    (%rdi,%rax,8),%rax
cmp    %r9,%rax
jbe    1c59 <smatvec+0xb59>
cmp    -0x60(%rsp),%rsi
jae    1c59 <smatvec+0xb59>
xor    %ebx,%ebx
mov    %rsi,%rdi
test   $0x1,%bpl
je     1d5f <smatvec+0xc5f>
movsd  (%rdi),%xmm1
mulsd  %xmm0,%xmm1
add    $0x8,%rdi
addsd  (%r9,%rbx,8),%xmm1
movsd  %xmm1,(%r9,%rbx,8)
mov    %rbx,%rbp
or     $0x1,%rbp
jmp    1d62 <smatvec+0xc62>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,-0x40(%rsp)
je     1dbd <smatvec+0xcbd>
mov    -0x68(%rsp),%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rsi,%rdi,8),%xmm2
movupd 0x10(%rsi,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%r9,%rdi,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%r9,%rdi,8),%xmm2
movupd 0x20(%r9,%rdi,8),%xmm5
movupd 0x30(%r9,%rdi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%r9,%rdi,8)
movupd %xmm3,0x10(%r9,%rdi,8)
movupd 0x20(%rsi,%rdi,8),%xmm2
movupd 0x30(%rsi,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%r9,%rdi,8)
movupd %xmm3,0x30(%r9,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1c80 <smatvec+0xb80>
test   $0x1,%r12b
je     1d32 <smatvec+0xc32>
movupd (%rsi,%rdi,8),%xmm2
movupd 0x10(%rsi,%rdi,8),%xmm3
movupd (%r9,%rdi,8),%xmm4
movupd 0x10(%r9,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r9,%rdi,8)
movupd %xmm3,0x10(%r9,%rdi,8)
cmp    %rbp,%r8
je     1bc0 <smatvec+0xac0>
lea    (%rsi,%r8,8),%rdi
mov    %r8,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x50(%rsp),%rbp
test   $0x1,%bpl
jne    1c35 <smatvec+0xb35>
mov    %rbx,%rbp
not    %rbx
cmp    %r13,%rbx
je     1bc0 <smatvec+0xac0>
mov    -0x50(%rsp),%rbx
sub    %rbp,%rbx
lea    (%r15,%rbp,8),%r10
xor    %r11d,%r11d
nopl   (%rax)
movsd  (%rdi,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r10,%r11,8),%xmm1
movsd  %xmm1,-0x8(%r10,%r11,8)
movsd  0x8(%rdi,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r10,%r11,8),%xmm1
movsd  %xmm1,(%r10,%r11,8)
add    $0x2,%r11
cmp    %r11,%rbx
jne    1d80 <smatvec+0xc80>
jmp    1bc0 <smatvec+0xac0>
xor    %edi,%edi
test   $0x1,%r12b
jne    1cfd <smatvec+0xbfd>
jmp    1d32 <smatvec+0xc32>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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