void kernel_sgemv_t_2_lib8(int kmax, int kna, float *A, int sda, float *x,
                           float *y, int alg) {
  if (kmax <= 0)
    return;
  const int lda = 8;
  const int bs = 8;
  int k, ka = kmax - kna;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0;
  if (kna > 0) {
    k = 0;
    for (; k < kna; k++) {
      x_0 = x[0];
      y_0 += A[0 + lda * 0] * x_0;
      y_1 += A[0 + lda * 1] * x_0;
      A += 1;
      x += 1;
    }
    A += (sda - 1) * lda;
  }
  k = 0;
  for (; k < ka - bs + 1; k += bs) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    x_0 = x[4];
    x_1 = x[5];
    x_2 = x[6];
    x_3 = x[7];
    y_0 += A[4 + lda * 0] * x_0;
    y_1 += A[4 + lda * 1] * x_0;
    y_0 += A[5 + lda * 0] * x_1;
    y_1 += A[5 + lda * 1] * x_1;
    y_0 += A[6 + lda * 0] * x_2;
    y_1 += A[6 + lda * 1] * x_2;
    y_0 += A[7 + lda * 0] * x_3;
    y_1 += A[7 + lda * 1] * x_3;
    A += sda * bs;
    x += 8;
  }
  for (; k < ka; k++) {
    x_0 = x[0];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    A += 1;
    x += 1;
  }
  if (alg == 0) {
    y[0] = y_0;
    y[1] = y_1;
  } else if (alg == 1) {
    y[0] += y_0;
    y[1] += y_1;
  } else {
    y[0] -= y_0;
    y[1] -= y_1;
  }
}


x86 assembly (clang, -O0):
<kernel_sgemv_t_2_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     112b <kernel_sgemv_t_2_lib8+0x2b>
jmp    15c8 <kernel_sgemv_t_2_lib8+0x4c8>
movl   $0x8,-0x2c(%rbp)
movl   $0x8,-0x30(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
cmpl   $0x0,-0x8(%rbp)
jle    11fc <kernel_sgemv_t_2_lib8+0xfc>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11e1 <kernel_sgemv_t_2_lib8+0xe1>
mov    -0x20(%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  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1163 <kernel_sgemv_t_2_lib8+0x63>
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x8,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14b7 <kernel_sgemv_t_2_lib8+0x3b7>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%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  0x20(%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  0x4(%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  0x24(%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  0x8(%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  0x28(%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  0xc(%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  0x2c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%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  0x30(%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  0x14(%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  0x34(%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  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%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  0x1c(%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  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x34(%rbp)
jmp    1203 <kernel_sgemv_t_2_lib8+0x103>
jmp    14bc <kernel_sgemv_t_2_lib8+0x3bc>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    153a <kernel_sgemv_t_2_lib8+0x43a>
mov    -0x20(%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  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14bc <kernel_sgemv_t_2_lib8+0x3bc>
cmpl   $0x0,0x10(%rbp)
jne    1564 <kernel_sgemv_t_2_lib8+0x464>
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    15c8 <kernel_sgemv_t_2_lib8+0x4c8>
cmpl   $0x1,0x10(%rbp)
jne    1597 <kernel_sgemv_t_2_lib8+0x497>
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
jmp    15c3 <kernel_sgemv_t_2_lib8+0x4c3>
movss  -0x4c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
jmp    15c8 <kernel_sgemv_t_2_lib8+0x4c8>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_sgemv_t_2_lib8>:
push   %rbx
test   %edi,%edi
jle    1415 <kernel_sgemv_t_2_lib8+0x315>
mov    %edi,%r10d
sub    %esi,%r10d
test   %esi,%esi
jle    112a <kernel_sgemv_t_2_lib8+0x2a>
cmp    $0x1,%esi
jne    1133 <kernel_sgemv_t_2_lib8+0x33>
xorps  %xmm1,%xmm1
test   $0x1,%sil
jne    11ad <kernel_sgemv_t_2_lib8+0xad>
jmp    11cf <kernel_sgemv_t_2_lib8+0xcf>
xorps  %xmm8,%xmm8
jmp    11e4 <kernel_sgemv_t_2_lib8+0xe4>
mov    %esi,%r11d
and    $0xfffffffe,%r11d
xorps  %xmm1,%xmm1
xor    %ebx,%ebx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rbx,4),%xmm4
movss  0x4(%rdx,%rbx,4),%xmm8
movss  0x20(%rdx,%rbx,4),%xmm2
unpcklps %xmm2,%xmm4
movss  0x24(%rdx,%rbx,4),%xmm2
unpcklps %xmm2,%xmm8
movss  (%r8,%rbx,4),%xmm3
movss  0x4(%r8,%rbx,4),%xmm2
shufps $0x0,%xmm3,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm1,%xmm3
shufps $0x0,%xmm2,%xmm2
movaps %xmm8,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm3,%xmm1
add    $0xfffffffffffffff8,%rax
add    $0x2,%rbx
cmp    %ebx,%r11d
jne    1150 <kernel_sgemv_t_2_lib8+0x50>
sub    %rax,%rdx
sub    %rax,%r8
test   $0x1,%sil
je     11cf <kernel_sgemv_t_2_lib8+0xcf>
movss  (%rdx),%xmm8
movss  0x20(%rdx),%xmm2
unpcklps %xmm2,%xmm8
movss  (%r8),%xmm2
shufps $0x0,%xmm2,%xmm2
add    $0x4,%rdx
add    $0x4,%r8
movaps %xmm1,%xmm3
mulps  %xmm2,%xmm8
addps  %xmm3,%xmm8
lea    -0x8(,%rcx,8),%eax
cltq
lea    (%rdx,%rax,4),%rdx
xor    %eax,%eax
cmp    $0x8,%r10d
jl     1306 <kernel_sgemv_t_2_lib8+0x206>
lea    -0x7(%r10),%r11d
shl    $0x3,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
xor    %eax,%eax
movss  0x20(%rdx),%xmm1
movss  (%rdx),%xmm4
unpcklps %xmm1,%xmm4
movss  0x4(%rdx),%xmm5
movss  0x8(%rdx),%xmm6
movss  0xc(%rdx),%xmm2
movss  (%r8),%xmm7
movss  0x4(%r8),%xmm0
movss  0x8(%r8),%xmm3
movss  0xc(%r8),%xmm1
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm8,%xmm7
movss  0x24(%rdx),%xmm4
unpcklps %xmm4,%xmm5
shufps $0x0,%xmm0,%xmm0
mulps  %xmm5,%xmm0
addps  %xmm7,%xmm0
movss  0x28(%rdx),%xmm4
unpcklps %xmm4,%xmm6
shufps $0x0,%xmm3,%xmm3
mulps  %xmm6,%xmm3
addps  %xmm0,%xmm3
movss  0x2c(%rdx),%xmm0
unpcklps %xmm0,%xmm2
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm3,%xmm1
movss  0x30(%rdx),%xmm0
movss  0x10(%rdx),%xmm2
unpcklps %xmm0,%xmm2
movss  0x10(%r8),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
movss  0x34(%rdx),%xmm1
movss  0x14(%rdx),%xmm2
unpcklps %xmm1,%xmm2
movss  0x14(%r8),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm0,%xmm3
movss  0x38(%rdx),%xmm0
movss  0x18(%rdx),%xmm2
unpcklps %xmm0,%xmm2
movss  0x18(%r8),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm3,%xmm1
movss  0x3c(%rdx),%xmm0
movss  0x1c(%rdx),%xmm3
unpcklps %xmm0,%xmm3
movss  0x1c(%r8),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
movaps %xmm2,%xmm8
addps  %xmm1,%xmm8
add    $0x20,%r8
add    $0x8,%eax
add    %rcx,%rdx
cmp    %r11d,%eax
jl     1200 <kernel_sgemv_t_2_lib8+0x100>
addps  %xmm1,%xmm2
movaps %xmm2,%xmm8
mov    0x10(%rsp),%r11d
cmp    %r10d,%eax
jge    13b7 <kernel_sgemv_t_2_lib8+0x2b7>
mov    %eax,%ecx
not    %ecx
add    %edi,%ecx
sub    %eax,%edi
sub    %esi,%edi
test   $0x1,%dil
je     134b <kernel_sgemv_t_2_lib8+0x24b>
movss  (%rdx),%xmm1
movss  0x20(%rdx),%xmm2
unpcklps %xmm2,%xmm1
movss  (%r8),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm2
addps  %xmm2,%xmm8
add    $0x4,%rdx
add    $0x4,%r8
add    $0x1,%eax
cmp    %esi,%ecx
je     13b7 <kernel_sgemv_t_2_lib8+0x2b7>
mov    %eax,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rcx,4),%xmm0
movss  0x4(%rdx,%rcx,4),%xmm3
movss  0x20(%rdx,%rcx,4),%xmm1
unpcklps %xmm1,%xmm0
movss  0x24(%rdx,%rcx,4),%xmm1
unpcklps %xmm1,%xmm3
movss  (%r8,%rcx,4),%xmm1
movss  0x4(%r8,%rcx,4),%xmm2
shufps $0x0,%xmm1,%xmm1
mulps  %xmm0,%xmm1
addps  %xmm8,%xmm1
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
movaps %xmm2,%xmm8
addps  %xmm1,%xmm8
add    $0x2,%rcx
lea    (%rax,%rcx,1),%esi
cmp    %r10d,%esi
jl     1360 <kernel_sgemv_t_2_lib8+0x260>
addps  %xmm1,%xmm2
movaps %xmm2,%xmm8
cmp    $0x1,%r11d
je     13ce <kernel_sgemv_t_2_lib8+0x2ce>
test   %r11d,%r11d
jne    13f0 <kernel_sgemv_t_2_lib8+0x2f0>
movss  %xmm8,(%r9)
shufps $0x55,%xmm8,%xmm8
jmp    13e8 <kernel_sgemv_t_2_lib8+0x2e8>
movss  (%r9),%xmm0
addss  %xmm8,%xmm0
movss  %xmm0,(%r9)
shufps $0x55,%xmm8,%xmm8
addss  0x4(%r9),%xmm8
movss  %xmm8,0x4(%r9)
pop    %rbx
ret
movss  (%r9),%xmm0
movss  0x4(%r9),%xmm1
subss  %xmm8,%xmm0
movss  %xmm0,(%r9)
shufps $0x55,%xmm8,%xmm8
subss  %xmm8,%xmm1
movss  %xmm1,0x4(%r9)
pop    %rbx
ret

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

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