void kernel_strmv_un_4_lib4(int kmax, float *A, float *x, int alg, float *y,
                            float *z) {
  const int bs = 4;
  int k;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0;
  x_0 = x[0];
  x_1 = x[1];
  x_2 = x[2];
  x_3 = x[3];
  y_0 += A[0 + bs * 0] * x_0;
  y_0 += A[0 + bs * 1] * x_1;
  y_1 += A[1 + bs * 1] * x_1;
  y_0 += A[0 + bs * 2] * x_2;
  y_1 += A[1 + bs * 2] * x_2;
  y_2 += A[2 + bs * 2] * x_2;
  y_0 += A[0 + bs * 3] * x_3;
  y_1 += A[1 + bs * 3] * x_3;
  y_2 += A[2 + bs * 3] * x_3;
  y_3 += A[3 + bs * 3] * x_3;
  A += 4 * bs;
  x += 4;
  k = 4;
  for (; k < kmax - 3; k += 4) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + bs * 0] * x_0;
    y_1 += A[1 + bs * 0] * x_0;
    y_2 += A[2 + bs * 0] * x_0;
    y_3 += A[3 + bs * 0] * x_0;
    y_0 += A[0 + bs * 1] * x_1;
    y_1 += A[1 + bs * 1] * x_1;
    y_2 += A[2 + bs * 1] * x_1;
    y_3 += A[3 + bs * 1] * x_1;
    y_0 += A[0 + bs * 2] * x_2;
    y_1 += A[1 + bs * 2] * x_2;
    y_2 += A[2 + bs * 2] * x_2;
    y_3 += A[3 + bs * 2] * x_2;
    y_0 += A[0 + bs * 3] * x_3;
    y_1 += A[1 + bs * 3] * x_3;
    y_2 += A[2 + bs * 3] * x_3;
    y_3 += A[3 + bs * 3] * x_3;
    A += 4 * bs;
    x += 4;
  }
  for (; k < kmax; k++) {
    x_0 = x[0];
    y_0 += A[0 + bs * 0] * x_0;
    y_1 += A[1 + bs * 0] * x_0;
    y_2 += A[2 + bs * 0] * x_0;
    y_3 += A[3 + bs * 0] * x_0;
    A += 1 * bs;
    x += 1;
  }
  if (alg == 0) {
    z[0] = y_0;
    z[1] = y_1;
    z[2] = y_2;
    z[3] = y_3;
  } else if (alg == 1) {
    z[0] = y[0] + y_0;
    z[1] = y[1] + y_1;
    z[2] = y[2] + y_2;
    z[3] = y[3] + y_3;
  } else {
    z[0] = y[0] - y_0;
    z[1] = y[1] - y_1;
    z[2] = y[2] - y_2;
    z[3] = y[3] - y_3;
  }
}


x86 assembly (clang, -O0):
<kernel_strmv_un_4_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x4,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
movl   $0x4,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1543 <kernel_strmv_un_4_lib4+0x443>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x38(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x38(%rbp)
jmp    12d6 <kernel_strmv_un_4_lib4+0x1d6>
jmp    1548 <kernel_strmv_un_4_lib4+0x448>
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1606 <kernel_strmv_un_4_lib4+0x506>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1548 <kernel_strmv_un_4_lib4+0x448>
cmpl   $0x0,-0x1c(%rbp)
jne    164c <kernel_strmv_un_4_lib4+0x54c>
movss  -0x4c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0xc(%rax)
jmp    1714 <kernel_strmv_un_4_lib4+0x614>
cmpl   $0x1,-0x1c(%rbp)
jne    16b5 <kernel_strmv_un_4_lib4+0x5b5>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x4c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
addss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0xc(%rax)
jmp    170f <kernel_strmv_un_4_lib4+0x60f>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0xc(%rax)
jmp    1714 <kernel_strmv_un_4_lib4+0x614>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strmv_un_4_lib4>:
movss  0x4(%rdx),%xmm1
movss  0x8(%rdx),%xmm2
movss  (%rsi),%xmm0
mulss  (%rdx),%xmm0
xorps  %xmm3,%xmm3
addss  %xmm3,%xmm0
movss  0x10(%rsi),%xmm4
mulss  %xmm1,%xmm4
mulss  0x14(%rsi),%xmm1
addss  %xmm0,%xmm4
addss  %xmm3,%xmm1
movss  0x20(%rsi),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
movsd  0x24(%rsi),%xmm0
unpcklps %xmm2,%xmm2
mulps  %xmm0,%xmm2
xorps  %xmm0,%xmm0
xorps  %xmm4,%xmm4
movss  %xmm1,%xmm4
addps  %xmm2,%xmm4
movups 0x30(%rsi),%xmm1
movss  0xc(%rdx),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm2
movss  %xmm3,%xmm0
shufps $0x4c,%xmm4,%xmm0
shufps $0x78,%xmm0,%xmm0
addps  %xmm2,%xmm0
add    $0x40,%rsi
add    $0x10,%rdx
mov    $0x4,%eax
cmp    $0x8,%edi
jl     11fa <kernel_strmv_un_4_lib4+0xfa>
lea    -0x3(%rdi),%r10d
mov    $0x4,%eax
xchg   %ax,%ax
movups (%rsi),%xmm3
movups 0x10(%rsi),%xmm4
movups 0x20(%rsi),%xmm5
movups 0x30(%rsi),%xmm8
movss  (%rdx),%xmm7
movss  0x4(%rdx),%xmm6
movss  0x8(%rdx),%xmm2
movss  0xc(%rdx),%xmm1
shufps $0x0,%xmm7,%xmm7
mulps  %xmm3,%xmm7
addps  %xmm0,%xmm7
shufps $0x0,%xmm6,%xmm6
mulps  %xmm4,%xmm6
addps  %xmm7,%xmm6
shufps $0x0,%xmm2,%xmm2
mulps  %xmm5,%xmm2
addps  %xmm6,%xmm2
shufps $0x0,%xmm1,%xmm1
mulps  %xmm8,%xmm1
movaps %xmm1,%xmm0
addps  %xmm2,%xmm0
add    $0x4,%eax
add    $0x40,%rsi
add    $0x10,%rdx
cmp    %r10d,%eax
jl     1190 <kernel_strmv_un_4_lib4+0x90>
addps  %xmm2,%xmm1
mov    %edi,%eax
and    $0xfffffffc,%eax
movaps %xmm1,%xmm0
cmp    %edi,%eax
jge    1211 <kernel_strmv_un_4_lib4+0x111>
mov    %eax,%r10d
not    %r10d
test   $0x1,%dil
jne    1216 <kernel_strmv_un_4_lib4+0x116>
add    %edi,%r10d
jne    123a <kernel_strmv_un_4_lib4+0x13a>
jmp    1278 <kernel_strmv_un_4_lib4+0x178>
movaps %xmm0,%xmm1
jmp    1278 <kernel_strmv_un_4_lib4+0x178>
movups (%rsi),%xmm2
movss  (%rdx),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm0,%xmm1
add    $0x10,%rsi
add    $0x4,%rdx
or     $0x1,%eax
movaps %xmm1,%xmm0
add    %edi,%r10d
je     1278 <kernel_strmv_un_4_lib4+0x178>
sub    %eax,%edi
xor    %eax,%eax
xchg   %ax,%ax
movss  (%rdx,%rax,4),%xmm3
movss  0x4(%rdx,%rax,4),%xmm1
shufps $0x0,%xmm3,%xmm3
movups (%rsi),%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rsi),%xmm0
shufps $0x0,%xmm1,%xmm1
mulps  %xmm0,%xmm1
movaps %xmm1,%xmm0
addps  %xmm2,%xmm0
add    $0x2,%rax
add    $0x20,%rsi
cmp    %eax,%edi
jne    1240 <kernel_strmv_un_4_lib4+0x140>
addps  %xmm2,%xmm1
cmp    $0x1,%ecx
je     12ab <kernel_strmv_un_4_lib4+0x1ab>
test   %ecx,%ecx
jne    12f0 <kernel_strmv_un_4_lib4+0x1f0>
movss  %xmm1,(%r9)
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
movss  %xmm0,0x4(%r9)
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
movss  %xmm0,0x8(%r9)
shufps $0xff,%xmm1,%xmm1
movss  %xmm1,0xc(%r9)
ret
movss  (%r8),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r9)
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
addss  0x4(%r8),%xmm0
movss  %xmm0,0x4(%r9)
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addss  0x8(%r8),%xmm0
movss  %xmm0,0x8(%r9)
shufps $0xff,%xmm1,%xmm1
addss  0xc(%r8),%xmm1
movss  %xmm1,0xc(%r9)
ret
movss  (%r8),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%r9)
movss  0x4(%r8),%xmm0
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
subss  %xmm2,%xmm0
movss  %xmm0,0x4(%r9)
movss  0x8(%r8),%xmm0
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
subss  %xmm2,%xmm0
movss  %xmm0,0x8(%r9)
movss  0xc(%r8),%xmm0
shufps $0xff,%xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%r9)
ret

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

LLVM IR (-O2):
define void @kernel_strmv_un_4_lib4(i32 %0, float* nocapture %1, float* nocapture %2, i32 %3, float* nocapture %4, float* nocapture writeonly %5) {
%7 = load float, float* %2
%8 = getelementptr inbounds float, float* %2, i64 1
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %2, i64 2
%11 = load float, float* %10
%12 = getelementptr inbounds float, float* %2, i64 3
%13 = load float, float* %12
%14 = load float, float* %1
%15 = tail call float @llvm.fmuladd.f32(float %14, float %7, float 0.000000e+00)
%16 = getelementptr inbounds float, float* %1, i64 4
%17 = load float, float* %16
%18 = tail call float @llvm.fmuladd.f32(float %17, float %9, float %15)
%19 = getelementptr inbounds float, float* %1, i64 5
%20 = load float, float* %19
%21 = tail call float @llvm.fmuladd.f32(float %20, float %9, float 0.000000e+00)
%22 = getelementptr inbounds float, float* %1, i64 8
%23 = load float, float* %22
%24 = tail call float @llvm.fmuladd.f32(float %23, float %11, float %18)
%25 = getelementptr inbounds float, float* %1, i64 9
%26 = bitcast float* %25 to <2 x float>*
%27 = load <2 x float>, <2 x float>* %26
%28 = insertelement <2 x float> poison, float %11, i64 0
%29 = shufflevector <2 x float> %28, <2 x float> poison, <2 x i32> zeroinitializer
%30 = insertelement <2 x float> <float poison, float 0.000000e+00>, float %21, i64 0
%31 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %27, <2 x float> %29, <2 x float> %30)
%32 = getelementptr inbounds float, float* %1, i64 12
%33 = bitcast float* %32 to <4 x float>*
%34 = load <4 x float>, <4 x float>* %33
%35 = insertelement <4 x float> poison, float %13, i64 0
%36 = shufflevector <4 x float> %35, <4 x float> poison, <4 x i32> zeroinitializer
%37 = insertelement <4 x float> <float poison, float poison, float poison, float 0.000000e+00>, float %24, i64 0
%38 = shufflevector <2 x float> %31, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%39 = shufflevector <4 x float> %37, <4 x float> %38, <4 x i32> <i32 0, i32 4, i32 5, i32 3>
%40 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %34, <4 x float> %36, <4 x float> %39)
%41 = add nsw i32 %0, -3
%42 = getelementptr inbounds float, float* %1, i64 16
%43 = getelementptr inbounds float, float* %2, i64 4
%44 = icmp sgt i32 %0, 7
br i1 %44, label %80, label %51
45: ; preds = %80
%46 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %95, <4 x float> %97, <4 x float> %86)
%47 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %101, <4 x float> %103, <4 x float> %46)
%48 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %107, <4 x float> %109, <4 x float> %47)
%49 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %113, <4 x float> %115, <4 x float> %48)
%50 = and i32 %0, -4
br label %51
51: ; preds = %45, %6
%52 = phi i32 [ 4, %6 ], [ %50, %45 ]
%53 = phi float* [ %42, %6 ], [ %118, %45 ]
%54 = phi float* [ %43, %6 ], [ %119, %45 ]
%55 = phi <4 x float> [ %40, %6 ], [ %49, %45 ]
%56 = icmp slt i32 %52, %0
br i1 %56, label %57, label %146
57: ; preds = %51
%58 = xor i32 %52, -1
%59 = and i32 %0, 1
%60 = icmp eq i32 %59, 0
br i1 %60, label %72, label %61
61: ; preds = %57
%62 = load float, float* %54
%63 = bitcast float* %53 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = insertelement <4 x float> poison, float %62, i64 0
%66 = shufflevector <4 x float> %65, <4 x float> poison, <4 x i32> zeroinitializer
%67 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %64, <4 x float> %66, <4 x float> %55)
%68 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %64, <4 x float> %66, <4 x float> %55)
%69 = getelementptr inbounds float, float* %53, i64 4
%70 = getelementptr inbounds float, float* %54, i64 1
%71 = or i32 %52, 1
br label %72
72: ; preds = %61, %57
%73 = phi <4 x float> [ undef, %57 ], [ %68, %61 ]
%74 = phi i32 [ %52, %57 ], [ %71, %61 ]
%75 = phi float* [ %53, %57 ], [ %69, %61 ]
%76 = phi float* [ %54, %57 ], [ %70, %61 ]
%77 = phi <4 x float> [ %55, %57 ], [ %67, %61 ]
%78 = sub i32 0, %0
%79 = icmp eq i32 %58, %78
br i1 %79, label %146, label %121
80: ; preds = %6, %80
%81 = phi float* [ %119, %80 ], [ %43, %6 ]
%82 = phi float* [ %118, %80 ], [ %42, %6 ]
%83 = phi i32 [ %117, %80 ], [ 4, %6 ]
%84 = phi float* [ %82, %80 ], [ %1, %6 ]
%85 = phi float* [ %81, %80 ], [ %2, %6 ]
%86 = phi <4 x float> [ %116, %80 ], [ %40, %6 ]
%87 = load float, float* %81
%88 = getelementptr inbounds float, float* %85, i64 5
%89 = load float, float* %88
%90 = getelementptr inbounds float, float* %85, i64 6
%91 = load float, float* %90
%92 = getelementptr inbounds float, float* %85, i64 7
%93 = load float, float* %92
%94 = bitcast float* %82 to <4 x float>*
%95 = load <4 x float>, <4 x float>* %94
%96 = insertelement <4 x float> poison, float %87, i64 0
%97 = shufflevector <4 x float> %96, <4 x float> poison, <4 x i32> zeroinitializer
%98 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %95, <4 x float> %97, <4 x float> %86)
%99 = getelementptr inbounds float, float* %84, i64 20
%100 = bitcast float* %99 to <4 x float>*
%101 = load <4 x float>, <4 x float>* %100
%102 = insertelement <4 x float> poison, float %89, i64 0
%103 = shufflevector <4 x float> %102, <4 x float> poison, <4 x i32> zeroinitializer
%104 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %101, <4 x float> %103, <4 x float> %98)
%105 = getelementptr inbounds float, float* %84, i64 24
%106 = bitcast float* %105 to <4 x float>*
%107 = load <4 x float>, <4 x float>* %106
%108 = insertelement <4 x float> poison, float %91, i64 0
%109 = shufflevector <4 x float> %108, <4 x float> poison, <4 x i32> zeroinitializer
%110 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %107, <4 x float> %109, <4 x float> %104)
%111 = getelementptr inbounds float, float* %84, i64 28
%112 = bitcast float* %111 to <4 x float>*
%113 = load <4 x float>, <4 x float>* %112
%114 = insertelement <4 x float> poison, float %93, i64 0
%115 = shufflevector <4 x float> %114, <4 x float> poison, <4 x i32> zeroinitializer
%116 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %113, <4 x float> %115, <4 x float> %110)
%117 = add nuw nsw i32 %83, 4
%118 = getelementptr inbounds float, float* %82, i64 16
%119 = getelementptr inbounds float, float* %81, i64 4
%120 = icmp slt i32 %117, %41
br i1 %120, label %80, label %45
121: ; preds = %72, %121
%122 = phi i32 [ %142, %121 ], [ %74, %72 ]
%123 = phi float* [ %140, %121 ], [ %75, %72 ]
%124 = phi float* [ %141, %121 ], [ %76, %72 ]
%125 = phi <4 x float> [ %139, %121 ], [ %77, %72 ]
%126 = load float, float* %124
%127 = bitcast float* %123 to <4 x float>*
%128 = load <4 x float>, <4 x float>* %127
%129 = insertelement <4 x float> poison, float %126, i64 0
%130 = shufflevector <4 x float> %129, <4 x float> poison, <4 x i32> zeroinitializer
%131 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %128, <4 x float> %130, <4 x float> %125)
%132 = getelementptr inbounds float, float* %123, i64 4
%133 = getelementptr inbounds float, float* %124, i64 1
%134 = load float, float* %133
%135 = bitcast float* %132 to <4 x float>*
%136 = load <4 x float>, <4 x float>* %135
%137 = insertelement <4 x float> poison, float %134, i64 0
%138 = shufflevector <4 x float> %137, <4 x float> poison, <4 x i32> zeroinitializer
%139 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %136, <4 x float> %138, <4 x float> %131)
%140 = getelementptr inbounds float, float* %123, i64 8
%141 = getelementptr inbounds float, float* %124, i64 2
%142 = add nuw nsw i32 %122, 2
%143 = icmp eq i32 %142, %0
br i1 %143, label %144, label %121
144: ; preds = %121
%145 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %136, <4 x float> %138, <4 x float> %131)
br label %146
146: ; preds = %144, %72, %51
%147 = phi <4 x float> [ %55, %51 ], [ %73, %72 ], [ %145, %144 ]
switch i32 %3, label %173 [
i32 0, label %148
i32 1, label %155
]
148: ; preds = %146
%149 = extractelement <4 x float> %147, i64 0
store float %149, float* %5
%150 = getelementptr inbounds float, float* %5, i64 1
%151 = extractelement <4 x float> %147, i64 1
store float %151, float* %150
%152 = getelementptr inbounds float, float* %5, i64 2
%153 = extractelement <4 x float> %147, i64 2
store float %153, float* %152
%154 = extractelement <4 x float> %147, i64 3
br label %191
155: ; preds = %146
%156 = load float, float* %4
%157 = extractelement <4 x float> %147, i64 0
%158 = fadd float %157, %156
store float %158, float* %5
%159 = getelementptr inbounds float, float* %4, i64 1
%160 = load float, float* %159
%161 = extractelement <4 x float> %147, i64 1
%162 = fadd float %161, %160
%163 = getelementptr inbounds float, float* %5, i64 1
store float %162, float* %163
%164 = getelementptr inbounds float, float* %4, i64 2
%165 = load float, float* %164
%166 = extractelement <4 x float> %147, i64 2
%167 = fadd float %166, %165
%168 = getelementptr inbounds float, float* %5, i64 2
store float %167, float* %168
%169 = getelementptr inbounds float, float* %4, i64 3
%170 = load float, float* %169
%171 = extractelement <4 x float> %147, i64 3
%172 = fadd float %171, %170
br label %191
173: ; preds = %146
%174 = load float, float* %4
%175 = extractelement <4 x float> %147, i64 0
%176 = fsub float %174, %175
store float %176, float* %5
%177 = getelementptr inbounds float, float* %4, i64 1
%178 = load float, float* %177
%179 = extractelement <4 x float> %147, i64 1
%180 = fsub float %178, %179
%181 = getelementptr inbounds float, float* %5, i64 1
store float %180, float* %181
%182 = getelementptr inbounds float, float* %4, i64 2
%183 = load float, float* %182
%184 = extractelement <4 x float> %147, i64 2
%185 = fsub float %183, %184
%186 = getelementptr inbounds float, float* %5, i64 2
store float %185, float* %186
%187 = getelementptr inbounds float, float* %4, i64 3
%188 = load float, float* %187
%189 = extractelement <4 x float> %147, i64 3
%190 = fsub float %188, %189
br label %191
191: ; preds = %155, %173, %148
%192 = phi float [ %172, %155 ], [ %190, %173 ], [ %154, %148 ]
%193 = getelementptr inbounds float, float* %5, i64 3
store float %192, float* %193
ret void
}