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


x86 assembly (clang, -O0):
<kernel_sgemv_t_3_lib4>:
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_3_lib4+0x2b>
jmp    1590 <kernel_sgemv_t_3_lib4+0x490>
movl   $0x4,-0x2c(%rbp)
movl   $0x4,-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)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
cmpl   $0x0,-0x8(%rbp)
jle    1224 <kernel_sgemv_t_3_lib4+0x124>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1209 <kernel_sgemv_t_3_lib4+0x109>
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  0x10(%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  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%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    116b <kernel_sgemv_t_3_lib4+0x6b>
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x2,%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    $0x4,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1427 <kernel_sgemv_t_3_lib4+0x327>
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  0x10(%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  0x20(%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  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  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  0x24(%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  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  0x18(%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  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  0x1c(%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  0x2c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    122b <kernel_sgemv_t_3_lib4+0x12b>
jmp    142c <kernel_sgemv_t_3_lib4+0x32c>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    14ca <kernel_sgemv_t_3_lib4+0x3ca>
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  0x10(%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  0x20(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%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    142c <kernel_sgemv_t_3_lib4+0x32c>
cmpl   $0x0,0x10(%rbp)
jne    1502 <kernel_sgemv_t_3_lib4+0x402>
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1590 <kernel_sgemv_t_3_lib4+0x490>
cmpl   $0x1,0x10(%rbp)
jne    1548 <kernel_sgemv_t_3_lib4+0x448>
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)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
jmp    158b <kernel_sgemv_t_3_lib4+0x48b>
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)
movss  -0x54(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
jmp    1590 <kernel_sgemv_t_3_lib4+0x490>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_sgemv_t_3_lib4>:
test   %edi,%edi
jle    13c1 <kernel_sgemv_t_3_lib4+0x2c1>
sub    %esi,%edi
test   %esi,%esi
jle    1128 <kernel_sgemv_t_3_lib4+0x28>
cmp    $0x1,%esi
jne    1133 <kernel_sgemv_t_3_lib4+0x33>
xorps  %xmm3,%xmm3
xorps  %xmm0,%xmm0
test   $0x1,%sil
jne    11c6 <kernel_sgemv_t_3_lib4+0xc6>
jmp    11f3 <kernel_sgemv_t_3_lib4+0xf3>
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
jmp    1206 <kernel_sgemv_t_3_lib4+0x106>
mov    %esi,%r10d
and    $0xfffffffe,%r10d
xorps  %xmm3,%xmm3
xorps  %xmm0,%xmm0
xor    %eax,%eax
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r8,%rax,4),%xmm4
movss  0x4(%r8,%rax,4),%xmm2
movss  (%rdx,%rax,4),%xmm5
mulss  %xmm4,%xmm5
addss  %xmm0,%xmm5
movss  0x10(%rdx,%rax,4),%xmm0
movss  0x14(%rdx,%rax,4),%xmm1
movss  0x20(%rdx,%rax,4),%xmm6
unpcklps %xmm6,%xmm0
movss  0x24(%rdx,%rax,4),%xmm6
unpcklps %xmm6,%xmm1
shufps $0x0,%xmm4,%xmm4
mulps  %xmm0,%xmm4
addps  %xmm3,%xmm4
movss  0x4(%rdx,%rax,4),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
shufps $0x0,%xmm2,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm4,%xmm3
add    $0xfffffffffffffff8,%r11
add    $0x2,%rax
cmp    %eax,%r10d
jne    1150 <kernel_sgemv_t_3_lib4+0x50>
sub    %r11,%rdx
sub    %r11,%r8
test   $0x1,%sil
je     11f3 <kernel_sgemv_t_3_lib4+0xf3>
movss  (%r8),%xmm2
movss  (%rdx),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  0x10(%rdx),%xmm1
movss  0x20(%rdx),%xmm4
unpcklps %xmm4,%xmm1
shufps $0x0,%xmm2,%xmm2
add    $0x4,%rdx
add    $0x4,%r8
movaps %xmm3,%xmm4
mulps  %xmm2,%xmm1
addps  %xmm4,%xmm1
lea    -0x4(,%rcx,4),%eax
cltq
lea    (%rdx,%rax,4),%rdx
xor    %eax,%eax
cmp    $0x4,%edi
jl     12e7 <kernel_sgemv_t_3_lib4+0x1e7>
lea    -0x3(%rdi),%esi
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
xor    %eax,%eax
movss  (%r8),%xmm6
movss  0x4(%r8),%xmm4
movss  0x8(%r8),%xmm3
movss  0xc(%r8),%xmm2
movss  (%rdx),%xmm7
mulss  %xmm6,%xmm7
addss  %xmm0,%xmm7
movss  0x20(%rdx),%xmm0
movss  0x10(%rdx),%xmm5
unpcklps %xmm0,%xmm5
movss  0x14(%rdx),%xmm0
movss  0x18(%rdx),%xmm9
movss  0x1c(%rdx),%xmm8
shufps $0x0,%xmm6,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm1,%xmm6
movss  0x4(%rdx),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm7,%xmm1
movss  0x24(%rdx),%xmm5
unpcklps %xmm5,%xmm0
shufps $0x0,%xmm4,%xmm4
mulps  %xmm0,%xmm4
addps  %xmm6,%xmm4
movss  0x8(%rdx),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm1,%xmm5
movss  0x28(%rdx),%xmm0
unpcklps %xmm0,%xmm9
shufps $0x0,%xmm3,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm4,%xmm3
movss  0xc(%rdx),%xmm0
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
movss  0x2c(%rdx),%xmm1
unpcklps %xmm1,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm1
addps  %xmm3,%xmm1
add    $0x10,%r8
add    $0x4,%eax
add    %rcx,%rdx
cmp    %esi,%eax
jl     1220 <kernel_sgemv_t_3_lib4+0x120>
addps  %xmm3,%xmm2
movaps %xmm2,%xmm1
mov    0x8(%rsp),%r10d
cmp    %edi,%eax
jge    1343 <kernel_sgemv_t_3_lib4+0x243>
mov    %eax,%eax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm1,%xmm2
movss  (%r8,%rsi,4),%xmm3
movss  (%rdx,%rsi,4),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm1,%xmm0
movss  0x10(%rdx,%rsi,4),%xmm1
movss  0x20(%rdx,%rsi,4),%xmm4
unpcklps %xmm4,%xmm1
shufps $0x0,%xmm3,%xmm3
mulps  %xmm1,%xmm3
movaps %xmm3,%xmm1
addps  %xmm2,%xmm1
add    $0x1,%rsi
lea    (%rax,%rsi,1),%ecx
cmp    %edi,%ecx
jl     1300 <kernel_sgemv_t_3_lib4+0x200>
addps  %xmm2,%xmm3
movaps %xmm3,%xmm1
cmp    $0x1,%r10d
je     1364 <kernel_sgemv_t_3_lib4+0x264>
test   %r10d,%r10d
jne    138f <kernel_sgemv_t_3_lib4+0x28f>
movss  %xmm0,(%r9)
movss  %xmm1,0x4(%r9)
shufps $0x55,%xmm1,%xmm1
movss  %xmm1,0x8(%r9)
ret
addss  (%r9),%xmm0
movss  %xmm0,(%r9)
movss  0x4(%r9),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%r9)
shufps $0x55,%xmm1,%xmm1
addss  0x8(%r9),%xmm1
movss  %xmm1,0x8(%r9)
ret
movss  (%r9),%xmm2
movss  0x4(%r9),%xmm3
subss  %xmm0,%xmm2
movss  %xmm2,(%r9)
subss  %xmm1,%xmm3
movss  %xmm3,0x4(%r9)
movss  0x8(%r9),%xmm0
shufps $0x55,%xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%r9)
ret

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

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