void smatvec(ldm, nrow, ncol, M, vec, Mxvec) int ldm;
int nrow;
int ncol;
float *M;
float *vec;
float *Mxvec;
{
  float vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7;
  float *M0;
  register float *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    $0x18,%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,-0x94(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x94(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    144c <smatvec+0x34c>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    142f <smatvec+0x32f>
movss  -0x2c(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x60(%rbp)
mulss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x68(%rbp)
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x70(%rbp)
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x80(%rbp)
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x88(%rbp)
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x90(%rbp)
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x98(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    12f3 <smatvec+0x1f3>
mov    -0x4(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    112f <smatvec+0x2f>
jmp    1451 <smatvec+0x351>
mov    -0x94(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1605 <smatvec+0x505>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15e8 <smatvec+0x4e8>
movss  -0x2c(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x60(%rbp)
mulss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x68(%rbp)
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x70(%rbp)
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x98(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1538 <smatvec+0x438>
mov    -0x4(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1451 <smatvec+0x351>
jmp    160a <smatvec+0x50a>
mov    -0x94(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16bf <smatvec+0x5bf>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x94(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16a5 <smatvec+0x5a5>
movss  -0x2c(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x98(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    164d <smatvec+0x54d>
mov    -0x4(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    160a <smatvec+0x50a>
add    $0x18,%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,0x78(%rsp)
movslq %edi,%rax
mov    %esi,%r10d
cmp    $0x8,%edx
mov    %r9,0x18(%rsp)
mov    %rdx,0x70(%rsp)
mov    %esi,-0x4c(%rsp)
mov    %rax,-0x40(%rsp)
mov    %r10,-0x48(%rsp)
jl     1806 <smatvec+0x706>
add    $0xfffffff9,%edx
mov    %rdx,0x68(%rsp)
lea    0x0(,%rax,8),%edx
movslq %edx,%rdx
lea    (%r9,%r10,4),%rsi
mov    %rsi,0xe8(%rsp)
lea    (%rax,%rax,1),%rsi
mov    %rsi,0xe0(%rsp)
lea    (%rsi,%rsi,2),%rsi
mov    %rsi,0xd8(%rsp)
lea    (%rsi,%r10,1),%rsi
mov    %rsi,0xd0(%rsp)
lea    (%rax,%rax,4),%rsi
mov    %rsi,0xc8(%rsp)
lea    (%rsi,%r10,1),%rsi
mov    %rsi,0xc0(%rsp)
lea    0x0(,%rax,4),%r13
lea    (%r10,%rax,4),%rsi
mov    %rsi,0xb8(%rsp)
lea    (%rax,%rax,2),%rsi
mov    %rsi,0xb0(%rsp)
add    %r10,%rsi
mov    %rsi,0xa8(%rsp)
lea    (%r10,%rax,2),%rsi
mov    %rsi,0xa0(%rsp)
lea    0x0(,%rax,8),%rsi
sub    %rax,%rsi
mov    %r10d,%edi
and    $0xfffffffc,%edi
mov    %rdi,0x80(%rsp)
lea    (%rax,%r10,1),%rdi
mov    %rdi,0x90(%rsp)
mov    %rsi,0x98(%rsp)
add    %r10,%rsi
mov    %rsi,0x88(%rsp)
mov    %rdx,0xf0(%rsp)
lea    0x0(,%rdx,4),%rdx
mov    %rdx,0x60(%rsp)
xor    %r14d,%r14d
mov    %rcx,-0x18(%rsp)
xor    %esi,%esi
jmp    124e <smatvec+0x14e>
nopw   0x0(%rax,%rax,1)
mov    -0x58(%rsp),%rcx
add    0x60(%rsp),%rcx
add    $0x1,%r14
mov    -0x30(%rsp),%rsi
cmp    0x68(%rsp),%rsi
jae    180a <smatvec+0x70a>
mov    %rcx,-0x58(%rsp)
mov    %rsi,%rcx
add    $0x8,%rsi
mov    %rsi,-0x30(%rsp)
cmpl   $0x0,-0x4c(%rsp)
jle    1230 <smatvec+0x130>
mov    %r14,-0x60(%rsp)
lea    0x0(,%rcx,4),%rdi
mov    %rdi,%r8
or     $0x4,%r8
mov    %rdi,%r9
or     $0x8,%r9
mov    %rdi,%r10
or     $0xc,%r10
mov    %rdi,%rbx
or     $0x10,%rbx
mov    %rdi,%rdx
or     $0x14,%rdx
mov    0x78(%rsp),%rax
movss  (%rax,%rcx,4),%xmm11
mov    %rdi,%rcx
or     $0x18,%rcx
or     $0x1c,%rdi
movss  (%rax,%r8,1),%xmm10
mov    -0x40(%rsp),%rsi
mov    -0x58(%rsp),%r8
lea    (%r8,%rsi,4),%rbp
movss  (%rax,%r9,1),%xmm2
mov    -0x40(%rsp),%rsi
mov    %rbp,(%rsp)
lea    0x0(%rbp,%rsi,4),%rbp
movss  (%rax,%r10,1),%xmm3
mov    -0x40(%rsp),%rsi
mov    %rbp,-0x38(%rsp)
lea    0x0(%rbp,%rsi,4),%rbp
movss  (%rax,%rbx,1),%xmm12
mov    -0x40(%rsp),%rsi
mov    %rbp,-0x70(%rsp)
lea    0x0(%rbp,%rsi,4),%r12
movss  (%rax,%rdx,1),%xmm13
mov    -0x40(%rsp),%rdx
lea    (%r12,%rdx,4),%r10
movss  (%rax,%rcx,1),%xmm14
mov    -0x40(%rsp),%rcx
lea    (%r10,%rcx,4),%r11
movss  (%rax,%rdi,1),%xmm15
mov    -0x40(%rsp),%rax
lea    (%r11,%rax,4),%rsi
cmpl   $0x4,-0x4c(%rsp)
jae    1350 <smatvec+0x250>
xor    %edi,%edi
mov    %r8,%rcx
mov    0x18(%rsp),%r9
mov    -0x60(%rsp),%r14
mov    (%rsp),%rbp
mov    -0x38(%rsp),%rbx
jmp    1737 <smatvec+0x637>
nop
mov    %rsi,-0x68(%rsp)
mov    -0x60(%rsp),%rcx
imul   0xf0(%rsp),%rcx
mov    0xd8(%rsp),%rdx
mov    %r8,%r14
lea    (%rdx,%rcx,1),%r15
mov    0xd0(%rsp),%rdx
add    %rcx,%rdx
mov    0xc8(%rsp),%rsi
lea    (%rsi,%rcx,1),%rsi
mov    %rsi,0x50(%rsp)
mov    0xc0(%rsp),%rsi
lea    (%rsi,%rcx,1),%rdi
lea    0x0(%r13,%rcx,1),%rsi
mov    %rsi,-0x10(%rsp)
mov    0xb8(%rsp),%rsi
lea    (%rsi,%rcx,1),%r8
mov    0xb0(%rsp),%rsi
lea    (%rsi,%rcx,1),%rsi
mov    %rsi,-0x28(%rsp)
mov    0xa8(%rsp),%rsi
lea    (%rsi,%rcx,1),%rsi
mov    %rsi,0x58(%rsp)
mov    0xe0(%rsp),%rsi
lea    (%rsi,%rcx,1),%rsi
mov    %rsi,0x20(%rsp)
mov    0xa0(%rsp),%rsi
lea    (%rsi,%rcx,1),%rsi
mov    %rsi,-0x20(%rsp)
lea    (%rcx,%rax,1),%rsi
mov    %rsi,0x40(%rsp)
mov    0x90(%rsp),%rsi
add    %rcx,%rsi
mov    %rsi,-0x8(%rsp)
mov    -0x48(%rsp),%rbp
lea    (%rcx,%rbp,1),%rsi
mov    %rsi,0x30(%rsp)
mov    0x98(%rsp),%rsi
lea    (%rsi,%rcx,1),%rbx
add    0x88(%rsp),%rcx
mov    -0x18(%rsp),%rbp
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
mov    0x18(%rsp),%r9
cmp    %r9,%rdx
seta   -0x71(%rsp)
lea    0x0(,%r15,4),%rdx
add    %rbp,%rdx
mov    0xe8(%rsp),%rsi
cmp    %rsi,%rdx
lea    0x0(%rbp,%rdi,4),%rdx
setb   -0x72(%rsp)
cmp    %r9,%rdx
mov    0x50(%rsp),%rdx
lea    0x0(%rbp,%rdx,4),%rdx
seta   %dil
cmp    %rsi,%rdx
lea    0x0(%rbp,%r8,4),%rdx
setb   0x50(%rsp)
cmp    %r9,%rdx
mov    -0x10(%rsp),%rdx
lea    0x0(%rbp,%rdx,4),%rdx
seta   %r8b
cmp    %rsi,%rdx
mov    0x58(%rsp),%rdx
lea    0x0(%rbp,%rdx,4),%rdx
setb   -0x10(%rsp)
cmp    %r9,%rdx
mov    -0x28(%rsp),%rdx
lea    0x0(%rbp,%rdx,4),%rdx
seta   %r15b
cmp    %rsi,%rdx
mov    -0x20(%rsp),%rdx
lea    0x0(%rbp,%rdx,4),%rdx
setb   -0x28(%rsp)
cmp    %r9,%rdx
seta   -0x20(%rsp)
mov    0x20(%rsp),%rdx
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
cmp    %rsi,%rdx
mov    -0x8(%rsp),%rdx
lea    0x0(%rbp,%rdx,4),%rdx
setb   0x20(%rsp)
cmp    %r9,%rdx
mov    0x40(%rsp),%rdx
lea    0x0(%rbp,%rdx,4),%rdx
seta   0x40(%rsp)
cmp    %rsi,%rdx
mov    0x30(%rsp),%rdx
lea    0x0(%rbp,%rdx,4),%rdx
lea    0x0(%rbp,%rcx,4),%rcx
setb   0x30(%rsp)
cmp    %r9,%rdx
seta   %dl
cmp    %rsi,%r14
setb   -0x8(%rsp)
cmp    %r9,%rcx
seta   %r14b
lea    0x0(,%rbx,4),%rcx
add    %rbp,%rcx
cmp    %rsi,%rcx
setb   %bl
mov    -0x72(%rsp),%cl
test   %cl,-0x71(%rsp)
jne    17f1 <smatvec+0x6f1>
mov    %bl,0x58(%rsp)
and    0x50(%rsp),%dil
mov    (%rsp),%rbp
mov    -0x38(%rsp),%rbx
jne    1726 <smatvec+0x626>
and    -0x10(%rsp),%r8b
jne    1726 <smatvec+0x626>
and    -0x28(%rsp),%r15b
jne    1726 <smatvec+0x626>
mov    0x20(%rsp),%cl
and    %cl,-0x20(%rsp)
jne    1726 <smatvec+0x626>
mov    0x30(%rsp),%cl
and    %cl,0x40(%rsp)
jne    1726 <smatvec+0x626>
and    -0x8(%rsp),%dl
mov    -0x58(%rsp),%rbx
jne    1715 <smatvec+0x615>
and    0x58(%rsp),%r14b
jne    1715 <smatvec+0x615>
mov    0x80(%rsp),%rsi
mov    -0x68(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %rcx,-0x68(%rsp)
lea    (%r11,%rsi,4),%r11
lea    (%r10,%rsi,4),%r10
lea    (%r12,%rsi,4),%r12
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %rcx,-0x70(%rsp)
mov    -0x38(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
mov    %rcx,-0x38(%rsp)
lea    0x0(%rbp,%rsi,4),%r15
lea    (%rbx,%rsi,4),%rcx
movaps %xmm10,0x40(%rsp)
shufps $0x0,%xmm10,%xmm10
movaps %xmm11,(%rsp)
shufps $0x0,%xmm11,%xmm11
movaps %xmm2,0x30(%rsp)
shufps $0x0,%xmm2,%xmm2
movaps %xmm3,0x20(%rsp)
shufps $0x0,%xmm3,%xmm3
movaps %xmm12,%xmm4
shufps $0x0,%xmm12,%xmm4
movaps %xmm13,%xmm5
shufps $0x0,%xmm13,%xmm5
movaps %xmm14,%xmm6
shufps $0x0,%xmm14,%xmm6
movaps %xmm15,%xmm7
shufps $0x0,%xmm15,%xmm7
xor    %edi,%edi
nop
lea    (%rbx,%rdi,4),%rdx
movups (%rbx,%rdi,4),%xmm8
mulps  %xmm11,%xmm8
lea    (%rdx,%r13,1),%rbp
movups (%rdx,%rax,4),%xmm9
mulps  %xmm10,%xmm9
addps  %xmm8,%xmm9
add    %r13,%rbp
movups (%rdx,%rax,8),%xmm1
mulps  %xmm2,%xmm1
addps  %xmm9,%xmm1
mov    %rbp,%rdx
add    %r13,%rdx
movups 0x0(%rbp,%rax,4),%xmm0
mulps  %xmm3,%xmm0
addps  %xmm1,%xmm0
add    %r13,%rdx
movups 0x0(%rbp,%rax,8),%xmm1
mulps  %xmm4,%xmm1
addps  %xmm0,%xmm1
movups (%rdx,%rax,4),%xmm0
add    %r13,%rdx
mulps  %xmm5,%xmm0
addps  %xmm1,%xmm0
movups (%rdx,%rax,4),%xmm1
add    %r13,%rdx
mulps  %xmm6,%xmm1
addps  %xmm0,%xmm1
movups (%rdx,%rax,4),%xmm0
mulps  %xmm7,%xmm0
addps  %xmm1,%xmm0
movups (%r9,%rdi,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%r9,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    1650 <smatvec+0x550>
mov    %rsi,%rdi
cmp    -0x48(%rsp),%rsi
mov    -0x60(%rsp),%r14
movaps (%rsp),%xmm11
movaps 0x40(%rsp),%xmm10
mov    %r15,%rbp
movaps 0x30(%rsp),%xmm2
movaps 0x20(%rsp),%xmm3
mov    -0x38(%rsp),%rbx
mov    -0x68(%rsp),%rsi
mov    -0x70(%rsp),%r8
je     1230 <smatvec+0x130>
jmp    173c <smatvec+0x63c>
xor    %edi,%edi
mov    %rbx,%rcx
mov    -0x60(%rsp),%r14
mov    -0x38(%rsp),%rbx
jmp    1732 <smatvec+0x632>
xor    %edi,%edi
mov    -0x58(%rsp),%rcx
mov    -0x60(%rsp),%r14
mov    -0x68(%rsp),%rsi
mov    -0x70(%rsp),%r8
mov    %rdi,%rdx
lea    (%r9,%rdi,4),%rdi
mov    -0x48(%rsp),%r15
sub    %rdx,%r15
mov    %r8,%rdx
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%r8,4),%xmm0
mulss  %xmm10,%xmm0
movss  (%rcx,%r8,4),%xmm1
mulss  %xmm11,%xmm1
addss  %xmm0,%xmm1
movss  (%rbx,%r8,4),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  (%rdx,%r8,4),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movss  (%r12,%r8,4),%xmm0
mulss  %xmm12,%xmm0
addss  %xmm1,%xmm0
movss  (%r10,%r8,4),%xmm1
mulss  %xmm13,%xmm1
addss  %xmm0,%xmm1
movss  (%r11,%r8,4),%xmm0
mulss  %xmm14,%xmm0
addss  %xmm1,%xmm0
movss  (%rsi,%r8,4),%xmm1
mulss  %xmm15,%xmm1
addss  %xmm0,%xmm1
addss  (%rdi,%r8,4),%xmm1
movss  %xmm1,(%rdi,%r8,4)
add    $0x1,%r8
cmp    %r8,%r15
jne    1760 <smatvec+0x660>
jmp    1230 <smatvec+0x130>
xor    %edi,%edi
mov    -0x58(%rsp),%rcx
mov    -0x60(%rsp),%r14
mov    (%rsp),%rbp
jmp    171f <smatvec+0x61f>
xor    %esi,%esi
jmp    1814 <smatvec+0x714>
mov    0x70(%rsp),%rdx
mov    -0x48(%rsp),%r10
lea    -0x3(%rdx),%edi
cmp    %edi,%esi
mov    %rcx,-0x18(%rsp)
jge    1b75 <smatvec+0xa75>
lea    0x0(,%rax,4),%edx
movslq %edx,%rdx
mov    %esi,%esi
movslq %edi,%rdi
lea    (%r9,%r10,4),%rbp
mov    %rbp,0x60(%rsp)
lea    (%rax,%rax,2),%rbp
mov    %rbp,-0x68(%rsp)
add    %r10,%rbp
mov    %rbp,0x40(%rsp)
lea    (%rax,%rax,1),%rbp
mov    %rbp,0x30(%rsp)
lea    (%r10,%rax,2),%rbp
mov    %rbp,0x20(%rsp)
lea    (%rax,%r10,1),%rbp
mov    %rbp,-0x8(%rsp)
mov    %r10d,%ebp
and    $0xfffffffc,%ebp
mov    %rbp,-0x20(%rsp)
mov    %rdx,0x68(%rsp)
lea    0x0(,%rdx,4),%r14
lea    0x0(,%rax,4),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,-0x10(%rsp)
lea    0x0(,%r10,4),%r11
and    $0xfffffffffffffff0,%r11
xor    %r15d,%r15d
mov    %rcx,%r8
mov    %rdi,%rcx
mov    %rdi,-0x28(%rsp)
mov    %r14,(%rsp)
jmp    18d0 <smatvec+0x7d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %r14,%r8
add    $0x1,%r15
cmp    %rcx,%rsi
jge    1b6b <smatvec+0xa6b>
mov    %rsi,%rdx
add    $0x4,%rsi
cmpl   $0x0,-0x4c(%rsp)
jle    18c0 <smatvec+0x7c0>
mov    %rsi,-0x30(%rsp)
mov    %edx,%esi
shl    $0x2,%rsi
mov    %rsi,%rdi
or     $0x4,%rdi
mov    %rsi,%rbp
or     $0x8,%rbp
or     $0xc,%rsi
mov    -0x40(%rsp),%rbx
lea    (%r8,%rbx,4),%r12
lea    (%r12,%rbx,4),%r13
mov    0x78(%rsp),%rax
movss  (%rax,%rdx,4),%xmm0
movss  (%rax,%rdi,1),%xmm1
movss  (%rax,%rbp,1),%xmm2
movss  (%rax,%rsi,1),%xmm3
lea    0x0(,%rbx,4),%rdi
add    %r13,%rdi
cmpl   $0x4,-0x4c(%rsp)
jae    1950 <smatvec+0x850>
xor    %ebp,%ebp
mov    %r8,%rdx
mov    0x18(%rsp),%r9
mov    -0x30(%rsp),%rsi
jmp    1b10 <smatvec+0xa10>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rax
mov    %rbx,%rdx
mov    %r15,%rax
imul   0x68(%rsp),%rax
mov    %r10,%rbx
mov    -0x68(%rsp),%rcx
lea    (%rcx,%rax,1),%rsi
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,1),%rbp
mov    0x30(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,-0x38(%rsp)
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,1),%r14
lea    (%rax,%rdx,1),%rcx
mov    %rcx,-0x58(%rsp)
mov    -0x8(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,-0x60(%rsp)
add    %r10,%rax
mov    -0x18(%rsp),%rcx
lea    (%rcx,%rbp,4),%rbp
mov    0x18(%rsp),%r9
cmp    %r9,%rbp
lea    (%rcx,%rsi,4),%rdx
seta   -0x70(%rsp)
mov    0x60(%rsp),%r10
cmp    %r10,%rdx
lea    (%rcx,%r14,4),%rdx
setb   %sil
cmp    %r9,%rdx
mov    -0x38(%rsp),%rdx
lea    (%rcx,%rdx,4),%rbx
seta   %dl
cmp    %r10,%rbx
mov    -0x60(%rsp),%rbx
lea    (%rcx,%rbx,4),%rbx
setb   %r14b
cmp    %r9,%rbx
mov    -0x58(%rsp),%rbx
lea    (%rcx,%rbx,4),%rbp
seta   %bl
cmp    %r10,%rbp
lea    (%rcx,%rax,4),%rax
setb   %cl
cmp    %r9,%rax
seta   %al
cmp    %r10,%r8
setb   %bpl
test   %sil,-0x70(%rsp)
jne    1af2 <smatvec+0x9f2>
and    %r14b,%dl
jne    1af2 <smatvec+0x9f2>
and    %cl,%bl
mov    -0x48(%rsp),%r10
mov    -0x30(%rsp),%rsi
mov    -0x28(%rsp),%rcx
mov    (%rsp),%r14
jne    1aeb <smatvec+0x9eb>
and    %bpl,%al
jne    1aeb <smatvec+0x9eb>
mov    -0x20(%rsp),%rax
lea    (%rdi,%rax,4),%rdi
lea    0x0(%r13,%rax,4),%r13
lea    (%r12,%rax,4),%r12
lea    (%r8,%rax,4),%rdx
movaps %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm8
movaps %xmm0,%xmm9
shufps $0x0,%xmm0,%xmm9
movaps %xmm2,%xmm6
shufps $0x0,%xmm2,%xmm6
movaps %xmm3,%xmm7
shufps $0x0,%xmm3,%xmm7
xor    %ebp,%ebp
mov    %r8,%r14
mov    -0x40(%rsp),%rax
mov    -0x10(%rsp),%rbx
nop
movups (%r14),%xmm4
mulps  %xmm9,%xmm4
movups (%r14,%rax,4),%xmm5
mulps  %xmm8,%xmm5
addps  %xmm4,%xmm5
movups (%r14,%rax,8),%xmm4
mulps  %xmm6,%xmm4
addps  %xmm5,%xmm4
movups (%r14,%rbx,1),%xmm5
mulps  %xmm7,%xmm5
addps  %xmm4,%xmm5
movups (%r9,%rbp,1),%xmm4
addps  %xmm5,%xmm4
movups %xmm4,(%r9,%rbp,1)
add    $0x10,%r14
add    $0x10,%rbp
cmp    %rbp,%r11
jne    1a90 <smatvec+0x990>
mov    -0x20(%rsp),%rax
mov    %rax,%rbp
cmp    %r10,%rax
mov    (%rsp),%r14
je     18c0 <smatvec+0x7c0>
jmp    1b10 <smatvec+0xa10>
xor    %ebp,%ebp
mov    %r8,%rdx
jmp    1b10 <smatvec+0xa10>
xor    %ebp,%ebp
mov    %r8,%rdx
mov    -0x48(%rsp),%r10
mov    -0x30(%rsp),%rsi
mov    -0x28(%rsp),%rcx
mov    (%rsp),%r14
nopw   0x0(%rax,%rax,1)
lea    (%r9,%rbp,4),%rbx
mov    %r10,%rax
sub    %rbp,%rax
xor    %ebp,%ebp
nopl   0x0(%rax)
movss  (%r12,%rbp,4),%xmm4
mulss  %xmm1,%xmm4
movss  (%rdx,%rbp,4),%xmm5
mulss  %xmm0,%xmm5
addss  %xmm4,%xmm5
movss  0x0(%r13,%rbp,4),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm5,%xmm4
movss  (%rdi,%rbp,4),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
addss  (%rbx,%rbp,4),%xmm5
movss  %xmm5,(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1b20 <smatvec+0xa20>
jmp    18c0 <smatvec+0x7c0>
mov    %r8,-0x18(%rsp)
mov    0x70(%rsp),%rdx
cmp    %edx,%esi
jge    1dbe <smatvec+0xcbe>
mov    %esi,%edx
mov    -0x48(%rsp),%r13
lea    (%r9,%r13,4),%rsi
mov    %r13d,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%r12
mov    %r12,-0x30(%rsp)
shr    $0x3,%r12
add    $0x1,%r12
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x58(%rsp)
neg    %r13
mov    -0x40(%rsp),%rax
lea    0x0(,%rax,4),%r14
lea    0x4(%r9),%r15
xor    %ecx,%ecx
mov    -0x18(%rsp),%rax
jmp    1be1 <smatvec+0xae1>
nopl   0x0(%rax)
add    %r14,%rax
add    $0x1,%rcx
cmp    0x70(%rsp),%edx
jge    1dbe <smatvec+0xcbe>
mov    %rdx,%rdi
add    $0x1,%rdx
cmpl   $0x0,-0x4c(%rsp)
jle    1bd0 <smatvec+0xad0>
mov    0x78(%rsp),%rbp
movss  0x0(%rbp,%rdi,4),%xmm0
cmpl   $0x8,-0x4c(%rsp)
jae    1c10 <smatvec+0xb10>
xor    %ebx,%ebx
mov    %rax,%rdi
jmp    1d40 <smatvec+0xc40>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rdi
imul   -0x40(%rsp),%rdi
mov    -0x48(%rsp),%rbp
add    %rbp,%rdi
mov    -0x18(%rsp),%rbx
lea    (%rbx,%rdi,4),%rdi
cmp    %r9,%rdi
jbe    1c67 <smatvec+0xb67>
cmp    %rsi,%rax
jae    1c67 <smatvec+0xb67>
xor    %ebx,%ebx
mov    %rax,%rdi
test   $0x1,%bpl
je     1d4f <smatvec+0xc4f>
movss  (%rdi),%xmm1
mulss  %xmm0,%xmm1
add    $0x4,%rdi
addss  (%r9,%rbx,4),%xmm1
movss  %xmm1,(%r9,%rbx,4)
mov    %rbx,%rbp
or     $0x1,%rbp
jmp    1d52 <smatvec+0xc52>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,-0x30(%rsp)
je     1dad <smatvec+0xcad>
mov    -0x58(%rsp),%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,4),%xmm2
movups 0x10(%rax,%rdi,4),%xmm3
mulps  %xmm1,%xmm2
movups (%r9,%rdi,4),%xmm4
addps  %xmm2,%xmm4
movups 0x10(%r9,%rdi,4),%xmm2
movups 0x20(%r9,%rdi,4),%xmm5
movups 0x30(%r9,%rdi,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,(%r9,%rdi,4)
movups %xmm3,0x10(%r9,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm2
movups 0x30(%rax,%rdi,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,0x20(%r9,%rdi,4)
movups %xmm3,0x30(%r9,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1c90 <smatvec+0xb90>
test   $0x1,%r12b
je     1d24 <smatvec+0xc24>
movups (%rax,%rdi,4),%xmm2
movups 0x10(%rax,%rdi,4),%xmm3
movups (%r9,%rdi,4),%xmm4
movups 0x10(%r9,%rdi,4),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%r9,%rdi,4)
movups %xmm3,0x10(%r9,%rdi,4)
cmp    %rbp,%r8
je     1bd0 <smatvec+0xad0>
lea    (%rax,%r8,4),%rdi
mov    %r8,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x48(%rsp),%rbp
test   $0x1,%bpl
jne    1c43 <smatvec+0xb43>
mov    %rbx,%rbp
not    %rbx
cmp    %r13,%rbx
je     1bd0 <smatvec+0xad0>
mov    -0x48(%rsp),%rbx
sub    %rbp,%rbx
lea    (%r15,%rbp,4),%r10
xor    %r11d,%r11d
nopl   (%rax)
movss  (%rdi,%r11,4),%xmm1
mulss  %xmm0,%xmm1
addss  -0x4(%r10,%r11,4),%xmm1
movss  %xmm1,-0x4(%r10,%r11,4)
movss  0x4(%rdi,%r11,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r10,%r11,4),%xmm1
movss  %xmm1,(%r10,%r11,4)
add    $0x2,%r11
cmp    %r11,%rbx
jne    1d70 <smatvec+0xc70>
jmp    1bd0 <smatvec+0xad0>
xor    %edi,%edi
test   $0x1,%r12b
jne    1cf9 <smatvec+0xbf9>
jmp    1d24 <smatvec+0xc24>
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, float* %3, float* %4, float* %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca float*
%11 = alloca float*
%12 = alloca float*
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float*
%22 = alloca float*
%23 = alloca float*
%24 = alloca float*
%25 = alloca float*
%26 = alloca float*
%27 = alloca float*
%28 = alloca float*
%29 = alloca float*
%30 = alloca i32
%31 = alloca i32
store i32 %0, i32* %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store float* %3, float** %10
store float* %4, float** %11
store float* %5, float** %12
store i32 0, i32* %30
%32 = load float*, float** %10
%33 = getelementptr inbounds float, float* %32, i64 0
store float* %33, float** %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 float*, float** %21
store float* %40, float** %22
%41 = load float*, float** %22
%42 = load i32, i32* %7
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %41, i64 %43
store float* %44, float** %23
%45 = load float*, float** %23
%46 = load i32, i32* %7
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %45, i64 %47
store float* %48, float** %24
%49 = load float*, float** %24
%50 = load i32, i32* %7
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %49, i64 %51
store float* %52, float** %25
%53 = load float*, float** %25
%54 = load i32, i32* %7
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %53, i64 %55
store float* %56, float** %26
%57 = load float*, float** %26
%58 = load i32, i32* %7
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %57, i64 %59
store float* %60, float** %27
%61 = load float*, float** %27
%62 = load i32, i32* %7
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds float, float* %61, i64 %63
store float* %64, float** %28
%65 = load float*, float** %28
%66 = load i32, i32* %7
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %65, i64 %67
store float* %68, float** %29
%69 = load float*, float** %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 float, float* %69, i64 %72
%74 = load float, float* %73
store float %74, float* %13
%75 = load float*, float** %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 float, float* %75, i64 %78
%80 = load float, float* %79
store float %80, float* %14
%81 = load float*, float** %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 float, float* %81, i64 %84
%86 = load float, float* %85
store float %86, float* %15
%87 = load float*, float** %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 float, float* %87, i64 %90
%92 = load float, float* %91
store float %92, float* %16
%93 = load float*, float** %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 float, float* %93, i64 %96
%98 = load float, float* %97
store float %98, float* %17
%99 = load float*, float** %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 float, float* %99, i64 %102
%104 = load float, float* %103
store float %104, float* %18
%105 = load float*, float** %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 float, float* %105, i64 %108
%110 = load float, float* %109
store float %110, float* %19
%111 = load float*, float** %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 float, float* %111, i64 %114
%116 = load float, float* %115
store float %116, float* %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 float, float* %13
%123 = load float*, float** %22
%124 = getelementptr inbounds float, float* %123, i32 1
store float* %124, float** %22
%125 = load float, float* %123
%126 = load float, float* %14
%127 = load float*, float** %23
%128 = getelementptr inbounds float, float* %127, i32 1
store float* %128, float** %23
%129 = load float, float* %127
%130 = fmul float %126, %129
%131 = call float @llvm.fmuladd.f32(float %122, float %125, float %130)
%132 = load float, float* %15
%133 = load float*, float** %24
%134 = getelementptr inbounds float, float* %133, i32 1
store float* %134, float** %24
%135 = load float, float* %133
%136 = call float @llvm.fmuladd.f32(float %132, float %135, float %131)
%137 = load float, float* %16
%138 = load float*, float** %25
%139 = getelementptr inbounds float, float* %138, i32 1
store float* %139, float** %25
%140 = load float, float* %138
%141 = call float @llvm.fmuladd.f32(float %137, float %140, float %136)
%142 = load float, float* %17
%143 = load float*, float** %26
%144 = getelementptr inbounds float, float* %143, i32 1
store float* %144, float** %26
%145 = load float, float* %143
%146 = call float @llvm.fmuladd.f32(float %142, float %145, float %141)
%147 = load float, float* %18
%148 = load float*, float** %27
%149 = getelementptr inbounds float, float* %148, i32 1
store float* %149, float** %27
%150 = load float, float* %148
%151 = call float @llvm.fmuladd.f32(float %147, float %150, float %146)
%152 = load float, float* %19
%153 = load float*, float** %28
%154 = getelementptr inbounds float, float* %153, i32 1
store float* %154, float** %28
%155 = load float, float* %153
%156 = call float @llvm.fmuladd.f32(float %152, float %155, float %151)
%157 = load float, float* %20
%158 = load float*, float** %29
%159 = getelementptr inbounds float, float* %158, i32 1
store float* %159, float** %29
%160 = load float, float* %158
%161 = call float @llvm.fmuladd.f32(float %157, float %160, float %156)
%162 = load float*, float** %12
%163 = load i32, i32* %31
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %162, i64 %164
%166 = load float, float* %165
%167 = fadd float %166, %161
store float %167, float* %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 float*, float** %21
%175 = sext i32 %173 to i64
%176 = getelementptr inbounds float, float* %174, i64 %175
store float* %176, float** %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 float*, float** %21
store float* %184, float** %22
%185 = load float*, float** %22
%186 = load i32, i32* %7
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds float, float* %185, i64 %187
store float* %188, float** %23
%189 = load float*, float** %23
%190 = load i32, i32* %7
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float, float* %189, i64 %191
store float* %192, float** %24
%193 = load float*, float** %24
%194 = load i32, i32* %7
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float, float* %193, i64 %195
store float* %196, float** %25
%197 = load float*, float** %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 float, float* %197, i64 %200
%202 = load float, float* %201
store float %202, float* %13
%203 = load float*, float** %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 float, float* %203, i64 %206
%208 = load float, float* %207
store float %208, float* %14
%209 = load float*, float** %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 float, float* %209, i64 %212
%214 = load float, float* %213
store float %214, float* %15
%215 = load float*, float** %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 float, float* %215, i64 %218
%220 = load float, float* %219
store float %220, float* %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 float, float* %13
%227 = load float*, float** %22
%228 = getelementptr inbounds float, float* %227, i32 1
store float* %228, float** %22
%229 = load float, float* %227
%230 = load float, float* %14
%231 = load float*, float** %23
%232 = getelementptr inbounds float, float* %231, i32 1
store float* %232, float** %23
%233 = load float, float* %231
%234 = fmul float %230, %233
%235 = call float @llvm.fmuladd.f32(float %226, float %229, float %234)
%236 = load float, float* %15
%237 = load float*, float** %24
%238 = getelementptr inbounds float, float* %237, i32 1
store float* %238, float** %24
%239 = load float, float* %237
%240 = call float @llvm.fmuladd.f32(float %236, float %239, float %235)
%241 = load float, float* %16
%242 = load float*, float** %25
%243 = getelementptr inbounds float, float* %242, i32 1
store float* %243, float** %25
%244 = load float, float* %242
%245 = call float @llvm.fmuladd.f32(float %241, float %244, float %240)
%246 = load float*, float** %12
%247 = load i32, i32* %31
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds float, float* %246, i64 %248
%250 = load float, float* %249
%251 = fadd float %250, %245
store float %251, float* %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 float*, float** %21
%259 = sext i32 %257 to i64
%260 = getelementptr inbounds float, float* %258, i64 %259
store float* %260, float** %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 float*, float** %21
store float* %267, float** %22
%268 = load float*, float** %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 float, float* %268, i64 %271
%273 = load float, float* %272
store float %273, float* %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 float, float* %13
%280 = load float*, float** %22
%281 = getelementptr inbounds float, float* %280, i32 1
store float* %281, float** %22
%282 = load float, float* %280
%283 = load float*, float** %12
%284 = load i32, i32* %31
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds float, float* %283, i64 %285
%287 = load float, float* %286
%288 = call float @llvm.fmuladd.f32(float %279, float %282, float %287)
store float %288, float* %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 float*, float** %21
%295 = sext i32 %293 to i64
%296 = getelementptr inbounds float, float* %294, i64 %295
store float* %296, float** %21
br label %262
297: ; preds = %262
ret void
}

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