void kernel_strmv_u_t_4_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, y_3 = 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_3 += A[0 + lda * 3] * 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_3 += A[1 + lda * 3] * 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_3 += A[2 + lda * 3] * 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;
    y_3 += A[3 + lda * 3] * 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_3 += A[0 + lda * 3] * 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_3 += A[1 + lda * 3] * 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_3 += A[2 + lda * 3] * 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;
    y_3 += A[3 + lda * 3] * 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_3 += A[0 + lda * 3] * 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_3 += A[1 + lda * 3] * 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_3 += A[2 + lda * 3] * 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;
    y_3 += A[3 + lda * 3] * 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_3 += A[0 + lda * 3] * x_0;
  y_1 += A[1 + lda * 1] * x_1;
  y_2 += A[1 + lda * 2] * x_1;
  y_3 += A[1 + lda * 3] * x_1;
  y_2 += A[2 + lda * 2] * x_2;
  y_3 += A[2 + lda * 3] * x_2;
  y_3 += A[3 + lda * 3] * x_3;
  A += sda * bs;
  x += 4;
  if (alg == 0) {
    y[0] = y_0;
    y[1] = y_1;
    y[2] = y_2;
    y[3] = y_3;
  } else if (alg == 1) {
    y[0] += y_0;
    y[1] += y_1;
    y[2] += y_2;
    y[3] += y_3;
  } else {
    y[0] -= y_0;
    y[1] -= y_1;
    y[2] -= y_2;
    y[3] -= y_3;
  }
}


x86 assembly (clang, -O0):
<kernel_strmv_u_t_4_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)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    1622 <kernel_strmv_u_t_4_lib4+0x522>
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  0x30(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x34(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -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  0x30(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x34(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -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    114f <kernel_strmv_u_t_4_lib4+0x4f>
jmp    1627 <kernel_strmv_u_t_4_lib4+0x527>
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    18a0 <kernel_strmv_u_t_4_lib4+0x7a0>
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  0x30(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x34(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -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    1627 <kernel_strmv_u_t_4_lib4+0x527>
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  0x30(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x34(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  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  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%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    1a80 <kernel_strmv_u_t_4_lib4+0x980>
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)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
jmp    1b38 <kernel_strmv_u_t_4_lib4+0xa38>
cmpl   $0x1,-0x2c(%rbp)
jne    1ad9 <kernel_strmv_u_t_4_lib4+0x9d9>
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)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
jmp    1b33 <kernel_strmv_u_t_4_lib4+0xa33>
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)
movss  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
jmp    1b38 <kernel_strmv_u_t_4_lib4+0xa38>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strmv_u_t_4_lib4>:
push   %rbp
push   %rbx
cmp    $0x8,%edi
jl     12ce <kernel_strmv_u_t_4_lib4+0x1ce>
lea    -0x7(%rdi),%r11d
lea    0x0(,%rdx,4),%eax
cltq
lea    0x0(,%rax,8),%r10
shl    $0x2,%rax
xorps  %xmm3,%xmm3
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %rsi,%rbx
movss  0x30(%rsi),%xmm0
movss  0x20(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0x10(%rsi),%xmm0
movss  (%rsi),%xmm6
unpcklps %xmm0,%xmm6
movlhps %xmm1,%xmm6
movss  0x4(%rsi),%xmm7
movss  0x8(%rsi),%xmm4
movss  0xc(%rsi),%xmm8
movss  (%rcx),%xmm1
movss  0x4(%rcx),%xmm5
movss  0x8(%rcx),%xmm2
movss  0xc(%rcx),%xmm0
shufps $0x0,%xmm1,%xmm1
mulps  %xmm6,%xmm1
addps  %xmm3,%xmm1
movss  0x34(%rsi),%xmm3
movss  0x24(%rsi),%xmm6
unpcklps %xmm3,%xmm6
movss  0x14(%rsi),%xmm3
unpcklps %xmm3,%xmm7
movlhps %xmm6,%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm7,%xmm5
addps  %xmm1,%xmm5
movss  0x38(%rsi),%xmm1
movss  0x28(%rsi),%xmm3
unpcklps %xmm1,%xmm3
movss  0x18(%rsi),%xmm1
unpcklps %xmm1,%xmm4
movlhps %xmm3,%xmm4
shufps $0x0,%xmm2,%xmm2
mulps  %xmm4,%xmm2
addps  %xmm5,%xmm2
movss  0x3c(%rsi),%xmm1
movss  0x2c(%rsi),%xmm3
unpcklps %xmm1,%xmm3
movss  0x1c(%rsi),%xmm1
unpcklps %xmm1,%xmm8
movlhps %xmm3,%xmm8
shufps $0x0,%xmm0,%xmm0
mulps  %xmm8,%xmm0
addps  %xmm2,%xmm0
lea    (%rsi,%rax,1),%rsi
movss  0x30(%rbx,%rax,1),%xmm1
movss  0x20(%rbx,%rax,1),%xmm2
unpcklps %xmm1,%xmm2
movss  0x10(%rbx,%rax,1),%xmm1
movss  (%rbx,%rax,1),%xmm4
unpcklps %xmm1,%xmm4
movlhps %xmm2,%xmm4
movss  0x4(%rbx,%rax,1),%xmm2
movss  0x8(%rbx,%rax,1),%xmm3
movss  0xc(%rbx,%rax,1),%xmm1
movss  0x10(%rcx),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm4,%xmm5
addps  %xmm0,%xmm5
movss  0x34(%rbx,%rax,1),%xmm0
movss  0x24(%rbx,%rax,1),%xmm4
unpcklps %xmm0,%xmm4
movss  0x14(%rbx,%rax,1),%xmm0
unpcklps %xmm0,%xmm2
movlhps %xmm4,%xmm2
movss  0x14(%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm5,%xmm0
movss  0x38(%rbx,%rax,1),%xmm2
movss  0x28(%rbx,%rax,1),%xmm4
unpcklps %xmm2,%xmm4
movss  0x18(%rbx,%rax,1),%xmm2
unpcklps %xmm2,%xmm3
movlhps %xmm4,%xmm3
movss  0x18(%rcx),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
movss  0x3c(%rbx,%rax,1),%xmm0
movss  0x2c(%rbx,%rax,1),%xmm3
unpcklps %xmm0,%xmm3
movss  0x1c(%rbx,%rax,1),%xmm0
unpcklps %xmm0,%xmm1
movlhps %xmm3,%xmm1
movss  0x1c(%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,%xmm3
addps  %xmm2,%xmm3
add    $0x20,%rcx
add    $0x8,%ebp
add    %rax,%rsi
cmp    %r11d,%ebp
jl     1130 <kernel_strmv_u_t_4_lib4+0x30>
add    %r10,%rbx
addps  %xmm2,%xmm0
mov    %edi,%eax
and    $0xfffffff8,%eax
mov    %rbx,%rsi
jmp    12d3 <kernel_strmv_u_t_4_lib4+0x1d3>
xorps  %xmm0,%xmm0
xor    %eax,%eax
add    $0xfffffffd,%edi
cmp    %edi,%eax
jge    13bd <kernel_strmv_u_t_4_lib4+0x2bd>
shl    $0x2,%edx
movslq %edx,%rdx
shl    $0x2,%rdx
nopl   0x0(%rax,%rax,1)
movss  0x30(%rsi),%xmm1
movss  0x20(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  0x10(%rsi),%xmm1
movss  (%rsi),%xmm6
unpcklps %xmm1,%xmm6
movlhps %xmm2,%xmm6
movss  0x4(%rsi),%xmm7
movss  0x8(%rsi),%xmm4
movss  0xc(%rsi),%xmm8
movss  (%rcx),%xmm3
movss  0x4(%rcx),%xmm5
movss  0x8(%rcx),%xmm2
movss  0xc(%rcx),%xmm1
shufps $0x0,%xmm3,%xmm3
mulps  %xmm6,%xmm3
addps  %xmm0,%xmm3
movss  0x34(%rsi),%xmm0
movss  0x24(%rsi),%xmm6
unpcklps %xmm0,%xmm6
movss  0x14(%rsi),%xmm0
unpcklps %xmm0,%xmm7
movlhps %xmm6,%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm7,%xmm5
addps  %xmm3,%xmm5
movss  0x38(%rsi),%xmm0
movss  0x28(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movss  0x18(%rsi),%xmm0
unpcklps %xmm0,%xmm4
movlhps %xmm3,%xmm4
shufps $0x0,%xmm2,%xmm2
mulps  %xmm4,%xmm2
addps  %xmm5,%xmm2
movss  0x3c(%rsi),%xmm0
movss  0x2c(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movss  0x1c(%rsi),%xmm0
unpcklps %xmm0,%xmm8
movlhps %xmm3,%xmm8
shufps $0x0,%xmm1,%xmm1
mulps  %xmm8,%xmm1
movaps %xmm1,%xmm0
addps  %xmm2,%xmm0
add    $0x10,%rcx
add    $0x4,%eax
add    %rdx,%rsi
cmp    %edi,%eax
jl     12f0 <kernel_strmv_u_t_4_lib4+0x1f0>
addps  %xmm2,%xmm1
movaps %xmm1,%xmm0
movups (%rcx),%xmm2
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movss  0x10(%rsi),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm1,%xmm3
movaps %xmm0,%xmm1
shufps $0xff,%xmm0,%xmm1
movss  0x30(%rsi),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm1,%xmm5
movss  0x34(%rsi),%xmm6
movss  (%rsi),%xmm1
movss  0x14(%rsi),%xmm4
unpcklps %xmm4,%xmm1
movss  0x20(%rsi),%xmm4
unpcklps %xmm6,%xmm4
movss  0x24(%rsi),%xmm6
movaps %xmm0,%xmm7
unpckhpd %xmm0,%xmm7
unpcklps %xmm5,%xmm7
mulps  %xmm2,%xmm4
addps  %xmm7,%xmm4
movss  0x38(%rsi),%xmm5
unpcklps %xmm5,%xmm6
movss  0x3c(%rsi),%xmm5
movss  0x28(%rsi),%xmm7
unpcklps %xmm5,%xmm7
movlhps %xmm7,%xmm1
mulps  %xmm2,%xmm1
shufps $0xe9,%xmm2,%xmm2
mulps  %xmm6,%xmm2
addps  %xmm4,%xmm2
movlhps %xmm0,%xmm3
shufps $0x42,%xmm2,%xmm3
addps  %xmm3,%xmm1
cmp    $0x1,%r9d
je     1456 <kernel_strmv_u_t_4_lib4+0x356>
test   %r9d,%r9d
jne    1463 <kernel_strmv_u_t_4_lib4+0x363>
movups %xmm1,(%r8)
jmp    146e <kernel_strmv_u_t_4_lib4+0x36e>
movups (%r8),%xmm0
addps  %xmm0,%xmm1
movups %xmm1,(%r8)
jmp    146e <kernel_strmv_u_t_4_lib4+0x36e>
movups (%r8),%xmm0
subps  %xmm1,%xmm0
movups %xmm0,(%r8)
pop    %rbx
pop    %rbp
ret

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

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