void kernel_strmv_u_t_3_lib4(int kmax, float *A, int sda, float *x, float *y,
                             int alg) {
  const int lda = 4;
  const int bs = 4;
  int k;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0, y_2 = 0;
  k = 0;
  for (; k < kmax - 7; k += 8) {
    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;
    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 < kmax - 3; k += 4) {
    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;
  }
  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_1 += A[1 + lda * 1] * x_1;
  y_2 += A[1 + lda * 2] * x_1;
  y_2 += A[2 + lda * 2] * x_2;
  A += sda * bs;
  x += 4;
  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_strmv_u_t_3_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x4,-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)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    151a <kernel_strmv_u_t_3_lib4+0x41a>
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    -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    -0x38(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x38(%rbp)
jmp    1147 <kernel_strmv_u_t_3_lib4+0x47>
jmp    151f <kernel_strmv_u_t_3_lib4+0x41f>
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1718 <kernel_strmv_u_t_3_lib4+0x618>
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    -0x38(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x38(%rbp)
jmp    151f <kernel_strmv_u_t_3_lib4+0x41f>
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  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  0x28(%rax),%xmm0
movss  -0x44(%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)
cmpl   $0x0,-0x2c(%rbp)
jne    186a <kernel_strmv_u_t_3_lib4+0x76a>
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    18f8 <kernel_strmv_u_t_3_lib4+0x7f8>
cmpl   $0x1,-0x2c(%rbp)
jne    18b0 <kernel_strmv_u_t_3_lib4+0x7b0>
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    18f3 <kernel_strmv_u_t_3_lib4+0x7f3>
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    18f8 <kernel_strmv_u_t_3_lib4+0x7f8>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strmv_u_t_3_lib4>:
push   %rbp
push   %rbx
cmp    $0x8,%edi
jl     12ba <kernel_strmv_u_t_3_lib4+0x1ba>
lea    -0x7(%rdi),%r11d
lea    0x0(,%rdx,4),%eax
cltq
lea    0x0(,%rax,8),%r10
shl    $0x2,%rax
xorps  %xmm4,%xmm4
xor    %ebp,%ebp
xorps  %xmm1,%xmm1
nopl   0x0(%rax)
mov    %rsi,%rbx
movss  (%rcx),%xmm5
movss  0x4(%rcx),%xmm3
movss  0x8(%rcx),%xmm0
movss  0xc(%rcx),%xmm2
movss  (%rsi),%xmm7
mulss  %xmm5,%xmm7
addss  %xmm1,%xmm7
movss  0x20(%rsi),%xmm1
movss  0x10(%rsi),%xmm6
unpcklps %xmm1,%xmm6
movss  0x14(%rsi),%xmm1
movss  0x18(%rsi),%xmm9
movss  0x1c(%rsi),%xmm8
shufps $0x0,%xmm5,%xmm5
mulps  %xmm6,%xmm5
addps  %xmm4,%xmm5
movss  0x4(%rsi),%xmm4
mulss  %xmm3,%xmm4
addss  %xmm7,%xmm4
movss  0x24(%rsi),%xmm6
unpcklps %xmm6,%xmm1
shufps $0x0,%xmm3,%xmm3
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movss  0x8(%rsi),%xmm1
mulss  %xmm0,%xmm1
addss  %xmm4,%xmm1
movss  0x28(%rsi),%xmm4
unpcklps %xmm4,%xmm9
shufps $0x0,%xmm0,%xmm0
mulps  %xmm9,%xmm0
addps  %xmm3,%xmm0
movss  0xc(%rsi),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm1,%xmm4
movss  0x2c(%rsi),%xmm1
unpcklps %xmm1,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
addps  %xmm0,%xmm2
movss  0x10(%rcx),%xmm5
movss  0x14(%rcx),%xmm1
movss  0x18(%rcx),%xmm3
movss  0x1c(%rcx),%xmm0
lea    (%rsi,%rax,1),%rsi
movss  (%rbx,%rax,1),%xmm7
mulss  %xmm5,%xmm7
addss  %xmm4,%xmm7
movss  0x20(%rbx,%rax,1),%xmm4
movss  0x10(%rbx,%rax,1),%xmm6
unpcklps %xmm4,%xmm6
movss  0x14(%rbx,%rax,1),%xmm4
movss  0x18(%rbx,%rax,1),%xmm9
movss  0x1c(%rbx,%rax,1),%xmm8
shufps $0x0,%xmm5,%xmm5
mulps  %xmm6,%xmm5
addps  %xmm2,%xmm5
movss  0x4(%rbx,%rax,1),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm7,%xmm2
movss  0x24(%rbx,%rax,1),%xmm6
unpcklps %xmm6,%xmm4
shufps $0x0,%xmm1,%xmm1
mulps  %xmm4,%xmm1
addps  %xmm5,%xmm1
movss  0x8(%rbx,%rax,1),%xmm4
mulss  %xmm3,%xmm4
addss  %xmm2,%xmm4
movss  0x28(%rbx,%rax,1),%xmm2
unpcklps %xmm2,%xmm9
shufps $0x0,%xmm3,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm1,%xmm3
movss  0xc(%rbx,%rax,1),%xmm1
mulss  %xmm0,%xmm1
addss  %xmm4,%xmm1
movss  0x2c(%rbx,%rax,1),%xmm2
unpcklps %xmm2,%xmm8
shufps $0x0,%xmm0,%xmm0
mulps  %xmm8,%xmm0
movaps %xmm0,%xmm4
addps  %xmm3,%xmm4
add    $0x20,%rcx
add    $0x8,%ebp
add    %rax,%rsi
cmp    %r11d,%ebp
jl     1130 <kernel_strmv_u_t_3_lib4+0x30>
add    %r10,%rbx
addps  %xmm3,%xmm0
mov    %edi,%eax
and    $0xfffffff8,%eax
mov    %rbx,%rsi
jmp    12c2 <kernel_strmv_u_t_3_lib4+0x1c2>
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
add    $0xfffffffd,%edi
cmp    %edi,%eax
jge    13a3 <kernel_strmv_u_t_3_lib4+0x2a3>
shl    $0x2,%edx
movslq %edx,%rdx
shl    $0x2,%rdx
nopw   0x0(%rax,%rax,1)
movss  (%rcx),%xmm6
movss  0x4(%rcx),%xmm4
movss  0x8(%rcx),%xmm3
movss  0xc(%rcx),%xmm2
movss  (%rsi),%xmm7
mulss  %xmm6,%xmm7
addss  %xmm1,%xmm7
movss  0x20(%rsi),%xmm1
movss  0x10(%rsi),%xmm5
unpcklps %xmm1,%xmm5
movss  0x14(%rsi),%xmm1
movss  0x18(%rsi),%xmm9
movss  0x1c(%rsi),%xmm8
shufps $0x0,%xmm6,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm0,%xmm6
movss  0x4(%rsi),%xmm0
mulss  %xmm4,%xmm0
addss  %xmm7,%xmm0
movss  0x24(%rsi),%xmm5
unpcklps %xmm5,%xmm1
shufps $0x0,%xmm4,%xmm4
mulps  %xmm1,%xmm4
addps  %xmm6,%xmm4
movss  0x8(%rsi),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm0,%xmm5
movss  0x28(%rsi),%xmm0
unpcklps %xmm0,%xmm9
shufps $0x0,%xmm3,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm4,%xmm3
movss  0xc(%rsi),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm5,%xmm1
movss  0x2c(%rsi),%xmm0
unpcklps %xmm0,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm0
addps  %xmm3,%xmm0
add    $0x10,%rcx
add    $0x4,%eax
add    %rdx,%rsi
cmp    %edi,%eax
jl     12e0 <kernel_strmv_u_t_3_lib4+0x1e0>
addps  %xmm3,%xmm2
movaps %xmm2,%xmm0
movss  (%rcx),%xmm3
movss  0x4(%rcx),%xmm4
movss  (%rsi),%xmm2
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  0x10(%rsi),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm0
mulss  0x20(%rsi),%xmm3
addss  %xmm0,%xmm3
movss  0x14(%rsi),%xmm0
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
mulss  0x24(%rsi),%xmm4
addss  %xmm3,%xmm4
movss  0x28(%rsi),%xmm1
mulss  0x8(%rcx),%xmm1
addss  %xmm4,%xmm1
cmp    $0x1,%r9d
je     1414 <kernel_strmv_u_t_3_lib4+0x314>
test   %r9d,%r9d
jne    1438 <kernel_strmv_u_t_3_lib4+0x338>
movss  %xmm2,(%r8)
movss  %xmm0,0x4(%r8)
movss  %xmm1,0x8(%r8)
jmp    1466 <kernel_strmv_u_t_3_lib4+0x366>
addss  (%r8),%xmm2
movss  %xmm2,(%r8)
addss  0x4(%r8),%xmm0
movss  %xmm0,0x4(%r8)
addss  0x8(%r8),%xmm1
movss  %xmm1,0x8(%r8)
jmp    1466 <kernel_strmv_u_t_3_lib4+0x366>
movss  (%r8),%xmm3
movss  0x4(%r8),%xmm4
subss  %xmm2,%xmm3
movss  %xmm3,(%r8)
subss  %xmm0,%xmm4
movss  %xmm4,0x4(%r8)
movss  0x8(%r8),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%r8)
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define void @kernel_strmv_u_t_3_lib4(i32 %0, float* %1, i32 %2, float* %3, float* %4, i32 %5) {
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32
%10 = alloca float*
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%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 i32 %2, i32* %9
store float* %3, float** %10
store float* %4, float** %11
store i32 %5, i32* %12
store i32 4, i32* %13
store i32 4, i32* %14
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store i32 0, i32* %15
br label %23
23: ; preds = %211, %6
%24 = load i32, i32* %15
%25 = load i32, i32* %7
%26 = sub nsw i32 %25, 7
%27 = icmp slt i32 %24, %26
br i1 %27, label %28, label %214
28: ; preds = %23
%29 = load float*, float** %10
%30 = getelementptr inbounds float, float* %29, i64 0
%31 = load float, float* %30
store float %31, float* %16
%32 = load float*, float** %10
%33 = getelementptr inbounds float, float* %32, i64 1
%34 = load float, float* %33
store float %34, float* %17
%35 = load float*, float** %10
%36 = getelementptr inbounds float, float* %35, i64 2
%37 = load float, float* %36
store float %37, float* %18
%38 = load float*, float** %10
%39 = getelementptr inbounds float, float* %38, i64 3
%40 = load float, float* %39
store float %40, float* %19
%41 = load float*, float** %8
%42 = getelementptr inbounds float, float* %41, i64 0
%43 = load float, float* %42
%44 = load float, float* %16
%45 = load float, float* %20
%46 = call float @llvm.fmuladd.f32(float %43, float %44, float %45)
store float %46, float* %20
%47 = load float*, float** %8
%48 = getelementptr inbounds float, float* %47, i64 4
%49 = load float, float* %48
%50 = load float, float* %16
%51 = load float, float* %21
%52 = call float @llvm.fmuladd.f32(float %49, float %50, float %51)
store float %52, float* %21
%53 = load float*, float** %8
%54 = getelementptr inbounds float, float* %53, i64 8
%55 = load float, float* %54
%56 = load float, float* %16
%57 = load float, float* %22
%58 = call float @llvm.fmuladd.f32(float %55, float %56, float %57)
store float %58, float* %22
%59 = load float*, float** %8
%60 = getelementptr inbounds float, float* %59, i64 1
%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 5
%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 9
%73 = load float, float* %72
%74 = load float, float* %17
%75 = load float, float* %22
%76 = call float @llvm.fmuladd.f32(float %73, float %74, float %75)
store float %76, float* %22
%77 = load float*, float** %8
%78 = getelementptr inbounds float, float* %77, i64 2
%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 6
%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 10
%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 3
%97 = load float, float* %96
%98 = load float, float* %19
%99 = load float, float* %20
%100 = call float @llvm.fmuladd.f32(float %97, float %98, float %99)
store float %100, float* %20
%101 = load float*, float** %8
%102 = getelementptr inbounds float, float* %101, i64 7
%103 = load float, float* %102
%104 = load float, float* %19
%105 = load float, float* %21
%106 = call float @llvm.fmuladd.f32(float %103, float %104, float %105)
store float %106, float* %21
%107 = load float*, float** %8
%108 = getelementptr inbounds float, float* %107, i64 11
%109 = load float, float* %108
%110 = load float, float* %19
%111 = load float, float* %22
%112 = call float @llvm.fmuladd.f32(float %109, float %110, float %111)
store float %112, float* %22
%113 = load i32, i32* %9
%114 = mul nsw i32 %113, 4
%115 = load float*, float** %8
%116 = sext i32 %114 to i64
%117 = getelementptr inbounds float, float* %115, i64 %116
store float* %117, float** %8
%118 = load float*, float** %10
%119 = getelementptr inbounds float, float* %118, i64 4
store float* %119, float** %10
%120 = load float*, float** %10
%121 = getelementptr inbounds float, float* %120, i64 0
%122 = load float, float* %121
store float %122, float* %16
%123 = load float*, float** %10
%124 = getelementptr inbounds float, float* %123, i64 1
%125 = load float, float* %124
store float %125, float* %17
%126 = load float*, float** %10
%127 = getelementptr inbounds float, float* %126, i64 2
%128 = load float, float* %127
store float %128, float* %18
%129 = load float*, float** %10
%130 = getelementptr inbounds float, float* %129, i64 3
%131 = load float, float* %130
store float %131, float* %19
%132 = load float*, float** %8
%133 = getelementptr inbounds float, float* %132, i64 0
%134 = load float, float* %133
%135 = load float, float* %16
%136 = load float, float* %20
%137 = call float @llvm.fmuladd.f32(float %134, float %135, float %136)
store float %137, float* %20
%138 = load float*, float** %8
%139 = getelementptr inbounds float, float* %138, i64 4
%140 = load float, float* %139
%141 = load float, float* %16
%142 = load float, float* %21
%143 = call float @llvm.fmuladd.f32(float %140, float %141, float %142)
store float %143, float* %21
%144 = load float*, float** %8
%145 = getelementptr inbounds float, float* %144, i64 8
%146 = load float, float* %145
%147 = load float, float* %16
%148 = load float, float* %22
%149 = call float @llvm.fmuladd.f32(float %146, float %147, float %148)
store float %149, float* %22
%150 = load float*, float** %8
%151 = getelementptr inbounds float, float* %150, i64 1
%152 = load float, float* %151
%153 = load float, float* %17
%154 = load float, float* %20
%155 = call float @llvm.fmuladd.f32(float %152, float %153, float %154)
store float %155, float* %20
%156 = load float*, float** %8
%157 = getelementptr inbounds float, float* %156, i64 5
%158 = load float, float* %157
%159 = load float, float* %17
%160 = load float, float* %21
%161 = call float @llvm.fmuladd.f32(float %158, float %159, float %160)
store float %161, float* %21
%162 = load float*, float** %8
%163 = getelementptr inbounds float, float* %162, i64 9
%164 = load float, float* %163
%165 = load float, float* %17
%166 = load float, float* %22
%167 = call float @llvm.fmuladd.f32(float %164, float %165, float %166)
store float %167, float* %22
%168 = load float*, float** %8
%169 = getelementptr inbounds float, float* %168, i64 2
%170 = load float, float* %169
%171 = load float, float* %18
%172 = load float, float* %20
%173 = call float @llvm.fmuladd.f32(float %170, float %171, float %172)
store float %173, float* %20
%174 = load float*, float** %8
%175 = getelementptr inbounds float, float* %174, i64 6
%176 = load float, float* %175
%177 = load float, float* %18
%178 = load float, float* %21
%179 = call float @llvm.fmuladd.f32(float %176, float %177, float %178)
store float %179, float* %21
%180 = load float*, float** %8
%181 = getelementptr inbounds float, float* %180, i64 10
%182 = load float, float* %181
%183 = load float, float* %18
%184 = load float, float* %22
%185 = call float @llvm.fmuladd.f32(float %182, float %183, float %184)
store float %185, float* %22
%186 = load float*, float** %8
%187 = getelementptr inbounds float, float* %186, i64 3
%188 = load float, float* %187
%189 = load float, float* %19
%190 = load float, float* %20
%191 = call float @llvm.fmuladd.f32(float %188, float %189, float %190)
store float %191, float* %20
%192 = load float*, float** %8
%193 = getelementptr inbounds float, float* %192, i64 7
%194 = load float, float* %193
%195 = load float, float* %19
%196 = load float, float* %21
%197 = call float @llvm.fmuladd.f32(float %194, float %195, float %196)
store float %197, float* %21
%198 = load float*, float** %8
%199 = getelementptr inbounds float, float* %198, i64 11
%200 = load float, float* %199
%201 = load float, float* %19
%202 = load float, float* %22
%203 = call float @llvm.fmuladd.f32(float %200, float %201, float %202)
store float %203, float* %22
%204 = load i32, i32* %9
%205 = mul nsw i32 %204, 4
%206 = load float*, float** %8
%207 = sext i32 %205 to i64
%208 = getelementptr inbounds float, float* %206, i64 %207
store float* %208, float** %8
%209 = load float*, float** %10
%210 = getelementptr inbounds float, float* %209, i64 4
store float* %210, float** %10
br label %211
211: ; preds = %28
%212 = load i32, i32* %15
%213 = add nsw i32 %212, 8
store i32 %213, i32* %15
br label %23
214: ; preds = %23
br label %215
215: ; preds = %312, %214
%216 = load i32, i32* %15
%217 = load i32, i32* %7
%218 = sub nsw i32 %217, 3
%219 = icmp slt i32 %216, %218
br i1 %219, label %220, label %315
220: ; preds = %215
%221 = load float*, float** %10
%222 = getelementptr inbounds float, float* %221, i64 0
%223 = load float, float* %222
store float %223, float* %16
%224 = load float*, float** %10
%225 = getelementptr inbounds float, float* %224, i64 1
%226 = load float, float* %225
store float %226, float* %17
%227 = load float*, float** %10
%228 = getelementptr inbounds float, float* %227, i64 2
%229 = load float, float* %228
store float %229, float* %18
%230 = load float*, float** %10
%231 = getelementptr inbounds float, float* %230, i64 3
%232 = load float, float* %231
store float %232, float* %19
%233 = load float*, float** %8
%234 = getelementptr inbounds float, float* %233, i64 0
%235 = load float, float* %234
%236 = load float, float* %16
%237 = load float, float* %20
%238 = call float @llvm.fmuladd.f32(float %235, float %236, float %237)
store float %238, float* %20
%239 = load float*, float** %8
%240 = getelementptr inbounds float, float* %239, i64 4
%241 = load float, float* %240
%242 = load float, float* %16
%243 = load float, float* %21
%244 = call float @llvm.fmuladd.f32(float %241, float %242, float %243)
store float %244, float* %21
%245 = load float*, float** %8
%246 = getelementptr inbounds float, float* %245, i64 8
%247 = load float, float* %246
%248 = load float, float* %16
%249 = load float, float* %22
%250 = call float @llvm.fmuladd.f32(float %247, float %248, float %249)
store float %250, float* %22
%251 = load float*, float** %8
%252 = getelementptr inbounds float, float* %251, i64 1
%253 = load float, float* %252
%254 = load float, float* %17
%255 = load float, float* %20
%256 = call float @llvm.fmuladd.f32(float %253, float %254, float %255)
store float %256, float* %20
%257 = load float*, float** %8
%258 = getelementptr inbounds float, float* %257, i64 5
%259 = load float, float* %258
%260 = load float, float* %17
%261 = load float, float* %21
%262 = call float @llvm.fmuladd.f32(float %259, float %260, float %261)
store float %262, float* %21
%263 = load float*, float** %8
%264 = getelementptr inbounds float, float* %263, i64 9
%265 = load float, float* %264
%266 = load float, float* %17
%267 = load float, float* %22
%268 = call float @llvm.fmuladd.f32(float %265, float %266, float %267)
store float %268, float* %22
%269 = load float*, float** %8
%270 = getelementptr inbounds float, float* %269, i64 2
%271 = load float, float* %270
%272 = load float, float* %18
%273 = load float, float* %20
%274 = call float @llvm.fmuladd.f32(float %271, float %272, float %273)
store float %274, float* %20
%275 = load float*, float** %8
%276 = getelementptr inbounds float, float* %275, i64 6
%277 = load float, float* %276
%278 = load float, float* %18
%279 = load float, float* %21
%280 = call float @llvm.fmuladd.f32(float %277, float %278, float %279)
store float %280, float* %21
%281 = load float*, float** %8
%282 = getelementptr inbounds float, float* %281, i64 10
%283 = load float, float* %282
%284 = load float, float* %18
%285 = load float, float* %22
%286 = call float @llvm.fmuladd.f32(float %283, float %284, float %285)
store float %286, float* %22
%287 = load float*, float** %8
%288 = getelementptr inbounds float, float* %287, i64 3
%289 = load float, float* %288
%290 = load float, float* %19
%291 = load float, float* %20
%292 = call float @llvm.fmuladd.f32(float %289, float %290, float %291)
store float %292, float* %20
%293 = load float*, float** %8
%294 = getelementptr inbounds float, float* %293, i64 7
%295 = load float, float* %294
%296 = load float, float* %19
%297 = load float, float* %21
%298 = call float @llvm.fmuladd.f32(float %295, float %296, float %297)
store float %298, float* %21
%299 = load float*, float** %8
%300 = getelementptr inbounds float, float* %299, i64 11
%301 = load float, float* %300
%302 = load float, float* %19
%303 = load float, float* %22
%304 = call float @llvm.fmuladd.f32(float %301, float %302, float %303)
store float %304, float* %22
%305 = load i32, i32* %9
%306 = mul nsw i32 %305, 4
%307 = load float*, float** %8
%308 = sext i32 %306 to i64
%309 = getelementptr inbounds float, float* %307, i64 %308
store float* %309, float** %8
%310 = load float*, float** %10
%311 = getelementptr inbounds float, float* %310, i64 4
store float* %311, float** %10
br label %312
312: ; preds = %220
%313 = load i32, i32* %15
%314 = add nsw i32 %313, 4
store i32 %314, i32* %15
br label %215
315: ; preds = %215
%316 = load float*, float** %10
%317 = getelementptr inbounds float, float* %316, i64 0
%318 = load float, float* %317
store float %318, float* %16
%319 = load float*, float** %10
%320 = getelementptr inbounds float, float* %319, i64 1
%321 = load float, float* %320
store float %321, float* %17
%322 = load float*, float** %10
%323 = getelementptr inbounds float, float* %322, i64 2
%324 = load float, float* %323
store float %324, float* %18
%325 = load float*, float** %10
%326 = getelementptr inbounds float, float* %325, i64 3
%327 = load float, float* %326
store float %327, float* %19
%328 = load float*, float** %8
%329 = getelementptr inbounds float, float* %328, i64 0
%330 = load float, float* %329
%331 = load float, float* %16
%332 = load float, float* %20
%333 = call float @llvm.fmuladd.f32(float %330, float %331, float %332)
store float %333, float* %20
%334 = load float*, float** %8
%335 = getelementptr inbounds float, float* %334, i64 4
%336 = load float, float* %335
%337 = load float, float* %16
%338 = load float, float* %21
%339 = call float @llvm.fmuladd.f32(float %336, float %337, float %338)
store float %339, float* %21
%340 = load float*, float** %8
%341 = getelementptr inbounds float, float* %340, i64 8
%342 = load float, float* %341
%343 = load float, float* %16
%344 = load float, float* %22
%345 = call float @llvm.fmuladd.f32(float %342, float %343, float %344)
store float %345, float* %22
%346 = load float*, float** %8
%347 = getelementptr inbounds float, float* %346, i64 5
%348 = load float, float* %347
%349 = load float, float* %17
%350 = load float, float* %21
%351 = call float @llvm.fmuladd.f32(float %348, float %349, float %350)
store float %351, float* %21
%352 = load float*, float** %8
%353 = getelementptr inbounds float, float* %352, i64 9
%354 = load float, float* %353
%355 = load float, float* %17
%356 = load float, float* %22
%357 = call float @llvm.fmuladd.f32(float %354, float %355, float %356)
store float %357, float* %22
%358 = load float*, float** %8
%359 = getelementptr inbounds float, float* %358, i64 10
%360 = load float, float* %359
%361 = load float, float* %18
%362 = load float, float* %22
%363 = call float @llvm.fmuladd.f32(float %360, float %361, float %362)
store float %363, float* %22
%364 = load i32, i32* %9
%365 = mul nsw i32 %364, 4
%366 = load float*, float** %8
%367 = sext i32 %365 to i64
%368 = getelementptr inbounds float, float* %366, i64 %367
store float* %368, float** %8
%369 = load float*, float** %10
%370 = getelementptr inbounds float, float* %369, i64 4
store float* %370, float** %10
%371 = load i32, i32* %12
%372 = icmp eq i32 %371, 0
br i1 %372, label %373, label %383
373: ; preds = %315
%374 = load float, float* %20
%375 = load float*, float** %11
%376 = getelementptr inbounds float, float* %375, i64 0
store float %374, float* %376
%377 = load float, float* %21
%378 = load float*, float** %11
%379 = getelementptr inbounds float, float* %378, i64 1
store float %377, float* %379
%380 = load float, float* %22
%381 = load float*, float** %11
%382 = getelementptr inbounds float, float* %381, i64 2
store float %380, float* %382
br label %419
383: ; preds = %315
%384 = load i32, i32* %12
%385 = icmp eq i32 %384, 1
br i1 %385, label %386, label %402
386: ; preds = %383
%387 = load float, float* %20
%388 = load float*, float** %11
%389 = getelementptr inbounds float, float* %388, i64 0
%390 = load float, float* %389
%391 = fadd float %390, %387
store float %391, float* %389
%392 = load float, float* %21
%393 = load float*, float** %11
%394 = getelementptr inbounds float, float* %393, i64 1
%395 = load float, float* %394
%396 = fadd float %395, %392
store float %396, float* %394
%397 = load float, float* %22
%398 = load float*, float** %11
%399 = getelementptr inbounds float, float* %398, i64 2
%400 = load float, float* %399
%401 = fadd float %400, %397
store float %401, float* %399
br label %418
402: ; preds = %383
%403 = load float, float* %20
%404 = load float*, float** %11
%405 = getelementptr inbounds float, float* %404, i64 0
%406 = load float, float* %405
%407 = fsub float %406, %403
store float %407, float* %405
%408 = load float, float* %21
%409 = load float*, float** %11
%410 = getelementptr inbounds float, float* %409, i64 1
%411 = load float, float* %410
%412 = fsub float %411, %408
store float %412, float* %410
%413 = load float, float* %22
%414 = load float*, float** %11
%415 = getelementptr inbounds float, float* %414, i64 2
%416 = load float, float* %415
%417 = fsub float %416, %413
store float %417, float* %415
br label %418
418: ; preds = %402, %386
br label %419
419: ; preds = %418, %373
ret void
}

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