void kernel_strmv_u_n_8_lib4(int kmax, float *A0, float *A1, float *x, float *y,
                             int alg) {
  if (kmax <= 0)
    return;
  const int lda = 4;
  int k;
  float x_0, x_1, x_2, x_3, y_0 = 0, y_1 = 0, y_2 = 0, y_3 = 0, y_4 = 0,
                            y_5 = 0, y_6 = 0, y_7 = 0;
  x_0 = x[0];
  x_1 = x[1];
  x_2 = x[2];
  x_3 = x[3];
  y_0 += A0[0 + lda * 0] * x_0;
  y_0 += A0[0 + lda * 1] * x_1;
  y_1 += A0[1 + lda * 1] * x_1;
  y_0 += A0[0 + lda * 2] * x_2;
  y_1 += A0[1 + lda * 2] * x_2;
  y_2 += A0[2 + lda * 2] * x_2;
  y_0 += A0[0 + lda * 3] * x_3;
  y_1 += A0[1 + lda * 3] * x_3;
  y_2 += A0[2 + lda * 3] * x_3;
  y_3 += A0[3 + lda * 3] * x_3;
  A0 += 4 * lda;
  A1 += 4 * lda;
  x += 4;
  x_0 = x[0];
  x_1 = x[1];
  x_2 = x[2];
  x_3 = x[3];
  y_0 += A0[0 + lda * 0] * x_0;
  y_1 += A0[1 + lda * 0] * x_0;
  y_2 += A0[2 + lda * 0] * x_0;
  y_3 += A0[3 + lda * 0] * x_0;
  y_4 += A1[0 + lda * 0] * x_0;
  y_0 += A0[0 + lda * 1] * x_1;
  y_1 += A0[1 + lda * 1] * x_1;
  y_2 += A0[2 + lda * 1] * x_1;
  y_3 += A0[3 + lda * 1] * x_1;
  y_4 += A1[0 + lda * 1] * x_1;
  y_5 += A1[1 + lda * 1] * x_1;
  y_0 += A0[0 + lda * 2] * x_2;
  y_1 += A0[1 + lda * 2] * x_2;
  y_2 += A0[2 + lda * 2] * x_2;
  y_3 += A0[3 + lda * 2] * x_2;
  y_4 += A1[0 + lda * 2] * x_2;
  y_5 += A1[1 + lda * 2] * x_2;
  y_6 += A1[2 + lda * 2] * x_2;
  y_0 += A0[0 + lda * 3] * x_3;
  y_1 += A0[1 + lda * 3] * x_3;
  y_2 += A0[2 + lda * 3] * x_3;
  y_3 += A0[3 + lda * 3] * x_3;
  y_4 += A1[0 + lda * 3] * x_3;
  y_5 += A1[1 + lda * 3] * x_3;
  y_6 += A1[2 + lda * 3] * x_3;
  y_7 += A1[3 + lda * 3] * x_3;
  A0 += 4 * lda;
  A1 += 4 * lda;
  x += 4;
  k = 8;
  for (; k < kmax - 3; k += 4) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A0[0 + lda * 0] * x_0;
    y_1 += A0[1 + lda * 0] * x_0;
    y_2 += A0[2 + lda * 0] * x_0;
    y_3 += A0[3 + lda * 0] * x_0;
    y_4 += A1[0 + lda * 0] * x_0;
    y_5 += A1[1 + lda * 0] * x_0;
    y_6 += A1[2 + lda * 0] * x_0;
    y_7 += A1[3 + lda * 0] * x_0;
    y_0 += A0[0 + lda * 1] * x_1;
    y_1 += A0[1 + lda * 1] * x_1;
    y_2 += A0[2 + lda * 1] * x_1;
    y_3 += A0[3 + lda * 1] * x_1;
    y_4 += A1[0 + lda * 1] * x_1;
    y_5 += A1[1 + lda * 1] * x_1;
    y_6 += A1[2 + lda * 1] * x_1;
    y_7 += A1[3 + lda * 1] * x_1;
    y_0 += A0[0 + lda * 2] * x_2;
    y_1 += A0[1 + lda * 2] * x_2;
    y_2 += A0[2 + lda * 2] * x_2;
    y_3 += A0[3 + lda * 2] * x_2;
    y_4 += A1[0 + lda * 2] * x_2;
    y_5 += A1[1 + lda * 2] * x_2;
    y_6 += A1[2 + lda * 2] * x_2;
    y_7 += A1[3 + lda * 2] * x_2;
    y_0 += A0[0 + lda * 3] * x_3;
    y_1 += A0[1 + lda * 3] * x_3;
    y_2 += A0[2 + lda * 3] * x_3;
    y_3 += A0[3 + lda * 3] * x_3;
    y_4 += A1[0 + lda * 3] * x_3;
    y_5 += A1[1 + lda * 3] * x_3;
    y_6 += A1[2 + lda * 3] * x_3;
    y_7 += A1[3 + lda * 3] * x_3;
    A0 += 4 * lda;
    A1 += 4 * lda;
    x += 4;
  }
  for (; k < kmax; k++) {
    x_0 = x[0];
    y_0 += A0[0 + lda * 0] * x_0;
    y_1 += A0[1 + lda * 0] * x_0;
    y_2 += A0[2 + lda * 0] * x_0;
    y_3 += A0[3 + lda * 0] * x_0;
    y_4 += A1[0 + lda * 0] * x_0;
    y_5 += A1[1 + lda * 0] * x_0;
    y_6 += A1[2 + lda * 0] * x_0;
    y_7 += A1[3 + lda * 0] * x_0;
    A0 += 1 * lda;
    A1 += 1 * lda;
    x += 1;
  }
  if (alg == 0) {
    y[0] = y_0;
    y[1] = y_1;
    y[2] = y_2;
    y[3] = y_3;
    y[4] = y_4;
    y[5] = y_5;
    y[6] = y_6;
    y[7] = y_7;
  } else if (alg == 1) {
    y[0] += y_0;
    y[1] += y_1;
    y[2] += y_2;
    y[3] += y_3;
    y[4] += y_4;
    y[5] += y_5;
    y[6] += y_6;
    y[7] += y_7;
  } else {
    y[0] -= y_0;
    y[1] -= y_1;
    y[2] -= y_2;
    y[3] -= y_3;
    y[4] -= y_4;
    y[5] -= y_5;
    y[6] -= y_6;
    y[7] -= y_7;
  }
}


x86 assembly (clang, -O0):
<kernel_strmv_u_n_8_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     112a <kernel_strmv_u_n_8_lib4+0x2a>
jmp    1e4f <kernel_strmv_u_n_8_lib4+0xd4f>
movl   $0x4,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%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)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%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  0x28(%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  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%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  0x18(%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  0x1c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%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  0x28(%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  0x2c(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
movl   $0x8,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1b23 <kernel_strmv_u_n_8_lib4+0xa23>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%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  0x18(%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  0x1c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%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  0x28(%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  0x2c(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    16ab <kernel_strmv_u_n_8_lib4+0x5ab>
jmp    1b28 <kernel_strmv_u_n_8_lib4+0xa28>
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c71 <kernel_strmv_u_n_8_lib4+0xb71>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b28 <kernel_strmv_u_n_8_lib4+0xa28>
cmpl   $0x0,-0x2c(%rbp)
jne    1cef <kernel_strmv_u_n_8_lib4+0xbef>
movss  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    1e4f <kernel_strmv_u_n_8_lib4+0xd4f>
cmpl   $0x1,-0x2c(%rbp)
jne    1d94 <kernel_strmv_u_n_8_lib4+0xc94>
movss  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x10(%rax),%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x14(%rax),%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x18(%rax),%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x1c(%rax),%xmm0
movss  %xmm0,0x1c(%rax)
jmp    1e4a <kernel_strmv_u_n_8_lib4+0xd4a>
movss  -0x48(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x10(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x5c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x14(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x60(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x18(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x64(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x1c(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
jmp    1e4f <kernel_strmv_u_n_8_lib4+0xd4f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strmv_u_n_8_lib4>:
test   %edi,%edi
jle    140e <kernel_strmv_u_n_8_lib4+0x30e>
movss  0x4(%rcx),%xmm1
movss  (%rsi),%xmm2
mulss  (%rcx),%xmm2
movss  0x8(%rcx),%xmm3
xorps  %xmm0,%xmm0
addss  %xmm0,%xmm2
movss  0x10(%rsi),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm2,%xmm4
mulss  0x14(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rsi),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
movsd  0x24(%rsi),%xmm2
unpcklps %xmm3,%xmm3
mulps  %xmm2,%xmm3
xorps  %xmm2,%xmm2
xorps  %xmm4,%xmm4
movss  %xmm1,%xmm4
addps  %xmm3,%xmm4
movups 0x30(%rsi),%xmm1
movss  0xc(%rcx),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm1,%xmm3
xorps  %xmm6,%xmm6
movss  %xmm5,%xmm6
shufps $0x4c,%xmm4,%xmm6
shufps $0x78,%xmm6,%xmm6
addps  %xmm3,%xmm6
movss  0x10(%rcx),%xmm4
movss  0x14(%rcx),%xmm1
movss  0x18(%rcx),%xmm3
movups 0x40(%rsi),%xmm5
movaps %xmm4,%xmm7
shufps $0x0,%xmm4,%xmm7
mulps  %xmm5,%xmm7
mulss  0x40(%rdx),%xmm4
addps  %xmm6,%xmm7
addss  %xmm0,%xmm4
movups 0x50(%rsi),%xmm5
movaps %xmm1,%xmm6
shufps $0x0,%xmm1,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm7,%xmm6
movss  0x50(%rdx),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  0x54(%rdx),%xmm1
addss  %xmm0,%xmm1
movups 0x60(%rsi),%xmm0
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
mulps  %xmm4,%xmm0
addps  %xmm6,%xmm0
mulss  0x60(%rdx),%xmm3
addss  %xmm5,%xmm3
movsd  0x64(%rdx),%xmm5
xorps  %xmm6,%xmm6
movss  %xmm1,%xmm6
mulps  %xmm4,%xmm5
addps  %xmm6,%xmm5
movups 0x70(%rsi),%xmm9
movss  0x1c(%rcx),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm9
addps  %xmm0,%xmm9
movups 0x70(%rdx),%xmm8
movss  %xmm3,%xmm2
shufps $0x4c,%xmm5,%xmm2
shufps $0x78,%xmm2,%xmm2
mulps  %xmm4,%xmm8
addps  %xmm2,%xmm8
sub    $0xffffffffffffff80,%rsi
sub    $0xffffffffffffff80,%rdx
add    $0x20,%rcx
mov    $0x8,%eax
cmp    $0xc,%edi
jb     1301 <kernel_strmv_u_n_8_lib4+0x201>
lea    -0x3(%rdi),%r10d
mov    $0x8,%eax
nopl   0x0(%rax)
movups (%rsi),%xmm0
movups 0x10(%rsi),%xmm6
movups 0x20(%rsi),%xmm4
movups 0x30(%rsi),%xmm10
movss  (%rcx),%xmm1
movss  0x4(%rcx),%xmm7
movss  0x8(%rcx),%xmm5
movss  0xc(%rcx),%xmm3
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm0
addps  %xmm9,%xmm0
movups (%rdx),%xmm2
movups 0x10(%rdx),%xmm9
movups 0x20(%rdx),%xmm11
movups 0x30(%rdx),%xmm12
mulps  %xmm1,%xmm2
addps  %xmm8,%xmm2
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm6
addps  %xmm0,%xmm6
mulps  %xmm9,%xmm7
addps  %xmm2,%xmm7
shufps $0x0,%xmm5,%xmm5
mulps  %xmm5,%xmm4
addps  %xmm6,%xmm4
mulps  %xmm11,%xmm5
addps  %xmm7,%xmm5
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm10
movaps %xmm10,%xmm9
addps  %xmm4,%xmm9
mulps  %xmm12,%xmm3
movaps %xmm3,%xmm8
addps  %xmm5,%xmm8
add    $0x40,%rsi
add    $0x40,%rdx
add    $0x10,%rcx
add    $0x4,%eax
cmp    %r10d,%eax
jl     1250 <kernel_strmv_u_n_8_lib4+0x150>
addps  %xmm5,%xmm3
addps  %xmm4,%xmm10
mov    %edi,%eax
and    $0xfffffffc,%eax
movaps %xmm10,%xmm9
movaps %xmm3,%xmm8
cmp    %edi,%eax
jge    131b <kernel_strmv_u_n_8_lib4+0x21b>
mov    %eax,%r10d
not    %r10d
test   $0x1,%dil
jne    1328 <kernel_strmv_u_n_8_lib4+0x228>
add    %edi,%r10d
jne    1360 <kernel_strmv_u_n_8_lib4+0x260>
jmp    13c8 <kernel_strmv_u_n_8_lib4+0x2c8>
movaps %xmm9,%xmm2
movaps %xmm8,%xmm3
jmp    13c8 <kernel_strmv_u_n_8_lib4+0x2c8>
movups (%rsi),%xmm2
movss  (%rcx),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm2
addps  %xmm9,%xmm2
movups (%rdx),%xmm3
mulps  %xmm4,%xmm3
addps  %xmm8,%xmm3
add    $0x10,%rsi
add    $0x10,%rdx
add    $0x4,%rcx
or     $0x1,%eax
movaps %xmm2,%xmm9
movaps %xmm3,%xmm8
add    %edi,%r10d
je     13c8 <kernel_strmv_u_n_8_lib4+0x2c8>
sub    %eax,%edi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx,%rax,1),%xmm0
movss  0x4(%rcx,%rax,1),%xmm3
shufps $0x0,%xmm0,%xmm0
movups (%rsi,%rax,4),%xmm4
movups 0x10(%rsi,%rax,4),%xmm2
mulps  %xmm0,%xmm4
addps  %xmm9,%xmm4
movups (%rdx,%rax,4),%xmm5
movups 0x10(%rdx,%rax,4),%xmm1
mulps  %xmm0,%xmm5
addps  %xmm8,%xmm5
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm2
movaps %xmm2,%xmm9
addps  %xmm4,%xmm9
mulps  %xmm1,%xmm3
movaps %xmm3,%xmm8
addps  %xmm5,%xmm8
add    $0x8,%rax
add    $0xfffffffe,%edi
jne    1370 <kernel_strmv_u_n_8_lib4+0x270>
addps  %xmm5,%xmm3
addps  %xmm4,%xmm2
cmp    $0x1,%r9d
je     13dd <kernel_strmv_u_n_8_lib4+0x2dd>
test   %r9d,%r9d
jne    13f6 <kernel_strmv_u_n_8_lib4+0x2f6>
movups %xmm2,(%r8)
movups %xmm3,0x10(%r8)
ret
movups (%r8),%xmm0
movups 0x10(%r8),%xmm1
addps  %xmm0,%xmm2
movups %xmm2,(%r8)
addps  %xmm1,%xmm3
movups %xmm3,0x10(%r8)
ret
movups (%r8),%xmm0
movups 0x10(%r8),%xmm1
subps  %xmm2,%xmm0
movups %xmm0,(%r8)
subps  %xmm3,%xmm1
movups %xmm1,0x10(%r8)
ret

LLVM IR (-O0):
define void @kernel_strmv_u_n_8_lib4(i32 %0, float* %1, float* %2, float* %3, float* %4, i32 %5) {
%7 = alloca i32
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
store i32 %0, i32* %7
store float* %1, float** %8
store float* %2, float** %9
store float* %3, float** %10
store float* %4, float** %11
store i32 %5, i32* %12
%27 = load i32, i32* %7
%28 = icmp sle i32 %27, 0
br i1 %28, label %29, label %30
29: ; preds = %6
br label %682
30: ; preds = %6
store i32 4, i32* %13
store float 0.000000e+00, float* %19
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store float 0.000000e+00, float* %23
store float 0.000000e+00, float* %24
store float 0.000000e+00, float* %25
store float 0.000000e+00, float* %26
%31 = load float*, float** %10
%32 = getelementptr inbounds float, float* %31, i64 0
%33 = load float, float* %32
store float %33, float* %15
%34 = load float*, float** %10
%35 = getelementptr inbounds float, float* %34, i64 1
%36 = load float, float* %35
store float %36, float* %16
%37 = load float*, float** %10
%38 = getelementptr inbounds float, float* %37, i64 2
%39 = load float, float* %38
store float %39, float* %17
%40 = load float*, float** %10
%41 = getelementptr inbounds float, float* %40, i64 3
%42 = load float, float* %41
store float %42, float* %18
%43 = load float*, float** %8
%44 = getelementptr inbounds float, float* %43, i64 0
%45 = load float, float* %44
%46 = load float, float* %15
%47 = load float, float* %19
%48 = call float @llvm.fmuladd.f32(float %45, float %46, float %47)
store float %48, float* %19
%49 = load float*, float** %8
%50 = getelementptr inbounds float, float* %49, i64 4
%51 = load float, float* %50
%52 = load float, float* %16
%53 = load float, float* %19
%54 = call float @llvm.fmuladd.f32(float %51, float %52, float %53)
store float %54, float* %19
%55 = load float*, float** %8
%56 = getelementptr inbounds float, float* %55, i64 5
%57 = load float, float* %56
%58 = load float, float* %16
%59 = load float, float* %20
%60 = call float @llvm.fmuladd.f32(float %57, float %58, float %59)
store float %60, float* %20
%61 = load float*, float** %8
%62 = getelementptr inbounds float, float* %61, i64 8
%63 = load float, float* %62
%64 = load float, float* %17
%65 = load float, float* %19
%66 = call float @llvm.fmuladd.f32(float %63, float %64, float %65)
store float %66, float* %19
%67 = load float*, float** %8
%68 = getelementptr inbounds float, float* %67, i64 9
%69 = load float, float* %68
%70 = load float, float* %17
%71 = load float, float* %20
%72 = call float @llvm.fmuladd.f32(float %69, float %70, float %71)
store float %72, float* %20
%73 = load float*, float** %8
%74 = getelementptr inbounds float, float* %73, i64 10
%75 = load float, float* %74
%76 = load float, float* %17
%77 = load float, float* %21
%78 = call float @llvm.fmuladd.f32(float %75, float %76, float %77)
store float %78, float* %21
%79 = load float*, float** %8
%80 = getelementptr inbounds float, float* %79, i64 12
%81 = load float, float* %80
%82 = load float, float* %18
%83 = load float, float* %19
%84 = call float @llvm.fmuladd.f32(float %81, float %82, float %83)
store float %84, float* %19
%85 = load float*, float** %8
%86 = getelementptr inbounds float, float* %85, i64 13
%87 = load float, float* %86
%88 = load float, float* %18
%89 = load float, float* %20
%90 = call float @llvm.fmuladd.f32(float %87, float %88, float %89)
store float %90, float* %20
%91 = load float*, float** %8
%92 = getelementptr inbounds float, float* %91, i64 14
%93 = load float, float* %92
%94 = load float, float* %18
%95 = load float, float* %21
%96 = call float @llvm.fmuladd.f32(float %93, float %94, float %95)
store float %96, float* %21
%97 = load float*, float** %8
%98 = getelementptr inbounds float, float* %97, i64 15
%99 = load float, float* %98
%100 = load float, float* %18
%101 = load float, float* %22
%102 = call float @llvm.fmuladd.f32(float %99, float %100, float %101)
store float %102, float* %22
%103 = load float*, float** %8
%104 = getelementptr inbounds float, float* %103, i64 16
store float* %104, float** %8
%105 = load float*, float** %9
%106 = getelementptr inbounds float, float* %105, i64 16
store float* %106, float** %9
%107 = load float*, float** %10
%108 = getelementptr inbounds float, float* %107, i64 4
store float* %108, float** %10
%109 = load float*, float** %10
%110 = getelementptr inbounds float, float* %109, i64 0
%111 = load float, float* %110
store float %111, float* %15
%112 = load float*, float** %10
%113 = getelementptr inbounds float, float* %112, i64 1
%114 = load float, float* %113
store float %114, float* %16
%115 = load float*, float** %10
%116 = getelementptr inbounds float, float* %115, i64 2
%117 = load float, float* %116
store float %117, float* %17
%118 = load float*, float** %10
%119 = getelementptr inbounds float, float* %118, i64 3
%120 = load float, float* %119
store float %120, float* %18
%121 = load float*, float** %8
%122 = getelementptr inbounds float, float* %121, i64 0
%123 = load float, float* %122
%124 = load float, float* %15
%125 = load float, float* %19
%126 = call float @llvm.fmuladd.f32(float %123, float %124, float %125)
store float %126, float* %19
%127 = load float*, float** %8
%128 = getelementptr inbounds float, float* %127, i64 1
%129 = load float, float* %128
%130 = load float, float* %15
%131 = load float, float* %20
%132 = call float @llvm.fmuladd.f32(float %129, float %130, float %131)
store float %132, float* %20
%133 = load float*, float** %8
%134 = getelementptr inbounds float, float* %133, i64 2
%135 = load float, float* %134
%136 = load float, float* %15
%137 = load float, float* %21
%138 = call float @llvm.fmuladd.f32(float %135, float %136, float %137)
store float %138, float* %21
%139 = load float*, float** %8
%140 = getelementptr inbounds float, float* %139, i64 3
%141 = load float, float* %140
%142 = load float, float* %15
%143 = load float, float* %22
%144 = call float @llvm.fmuladd.f32(float %141, float %142, float %143)
store float %144, float* %22
%145 = load float*, float** %9
%146 = getelementptr inbounds float, float* %145, i64 0
%147 = load float, float* %146
%148 = load float, float* %15
%149 = load float, float* %23
%150 = call float @llvm.fmuladd.f32(float %147, float %148, float %149)
store float %150, float* %23
%151 = load float*, float** %8
%152 = getelementptr inbounds float, float* %151, i64 4
%153 = load float, float* %152
%154 = load float, float* %16
%155 = load float, float* %19
%156 = call float @llvm.fmuladd.f32(float %153, float %154, float %155)
store float %156, float* %19
%157 = load float*, float** %8
%158 = getelementptr inbounds float, float* %157, i64 5
%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 6
%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 7
%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** %9
%176 = getelementptr inbounds float, float* %175, i64 4
%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** %9
%182 = getelementptr inbounds float, float* %181, i64 5
%183 = load float, float* %182
%184 = load float, float* %16
%185 = load float, float* %24
%186 = call float @llvm.fmuladd.f32(float %183, float %184, float %185)
store float %186, float* %24
%187 = load float*, float** %8
%188 = getelementptr inbounds float, float* %187, i64 8
%189 = load float, float* %188
%190 = load float, float* %17
%191 = load float, float* %19
%192 = call float @llvm.fmuladd.f32(float %189, float %190, float %191)
store float %192, float* %19
%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* %20
%198 = call float @llvm.fmuladd.f32(float %195, float %196, float %197)
store float %198, float* %20
%199 = load float*, float** %8
%200 = getelementptr inbounds float, float* %199, i64 10
%201 = load float, float* %200
%202 = load float, float* %17
%203 = load float, float* %21
%204 = call float @llvm.fmuladd.f32(float %201, float %202, float %203)
store float %204, float* %21
%205 = load float*, float** %8
%206 = getelementptr inbounds float, float* %205, i64 11
%207 = load float, float* %206
%208 = load float, float* %17
%209 = load float, float* %22
%210 = call float @llvm.fmuladd.f32(float %207, float %208, float %209)
store float %210, float* %22
%211 = load float*, float** %9
%212 = getelementptr inbounds float, float* %211, i64 8
%213 = load float, float* %212
%214 = load float, float* %17
%215 = load float, float* %23
%216 = call float @llvm.fmuladd.f32(float %213, float %214, float %215)
store float %216, float* %23
%217 = load float*, float** %9
%218 = getelementptr inbounds float, float* %217, i64 9
%219 = load float, float* %218
%220 = load float, float* %17
%221 = load float, float* %24
%222 = call float @llvm.fmuladd.f32(float %219, float %220, float %221)
store float %222, float* %24
%223 = load float*, float** %9
%224 = getelementptr inbounds float, float* %223, i64 10
%225 = load float, float* %224
%226 = load float, float* %17
%227 = load float, float* %25
%228 = call float @llvm.fmuladd.f32(float %225, float %226, float %227)
store float %228, float* %25
%229 = load float*, float** %8
%230 = getelementptr inbounds float, float* %229, i64 12
%231 = load float, float* %230
%232 = load float, float* %18
%233 = load float, float* %19
%234 = call float @llvm.fmuladd.f32(float %231, float %232, float %233)
store float %234, float* %19
%235 = load float*, float** %8
%236 = getelementptr inbounds float, float* %235, i64 13
%237 = load float, float* %236
%238 = load float, float* %18
%239 = load float, float* %20
%240 = call float @llvm.fmuladd.f32(float %237, float %238, float %239)
store float %240, float* %20
%241 = load float*, float** %8
%242 = getelementptr inbounds float, float* %241, i64 14
%243 = load float, float* %242
%244 = load float, float* %18
%245 = load float, float* %21
%246 = call float @llvm.fmuladd.f32(float %243, float %244, float %245)
store float %246, float* %21
%247 = load float*, float** %8
%248 = getelementptr inbounds float, float* %247, i64 15
%249 = load float, float* %248
%250 = load float, float* %18
%251 = load float, float* %22
%252 = call float @llvm.fmuladd.f32(float %249, float %250, float %251)
store float %252, float* %22
%253 = load float*, float** %9
%254 = getelementptr inbounds float, float* %253, i64 12
%255 = load float, float* %254
%256 = load float, float* %18
%257 = load float, float* %23
%258 = call float @llvm.fmuladd.f32(float %255, float %256, float %257)
store float %258, float* %23
%259 = load float*, float** %9
%260 = getelementptr inbounds float, float* %259, i64 13
%261 = load float, float* %260
%262 = load float, float* %18
%263 = load float, float* %24
%264 = call float @llvm.fmuladd.f32(float %261, float %262, float %263)
store float %264, float* %24
%265 = load float*, float** %9
%266 = getelementptr inbounds float, float* %265, i64 14
%267 = load float, float* %266
%268 = load float, float* %18
%269 = load float, float* %25
%270 = call float @llvm.fmuladd.f32(float %267, float %268, float %269)
store float %270, float* %25
%271 = load float*, float** %9
%272 = getelementptr inbounds float, float* %271, i64 15
%273 = load float, float* %272
%274 = load float, float* %18
%275 = load float, float* %26
%276 = call float @llvm.fmuladd.f32(float %273, float %274, float %275)
store float %276, float* %26
%277 = load float*, float** %8
%278 = getelementptr inbounds float, float* %277, i64 16
store float* %278, float** %8
%279 = load float*, float** %9
%280 = getelementptr inbounds float, float* %279, i64 16
store float* %280, float** %9
%281 = load float*, float** %10
%282 = getelementptr inbounds float, float* %281, i64 4
store float* %282, float** %10
store i32 8, i32* %14
br label %283
283: ; preds = %499, %30
%284 = load i32, i32* %14
%285 = load i32, i32* %7
%286 = sub nsw i32 %285, 3
%287 = icmp slt i32 %284, %286
br i1 %287, label %288, label %502
288: ; preds = %283
%289 = load float*, float** %10
%290 = getelementptr inbounds float, float* %289, i64 0
%291 = load float, float* %290
store float %291, float* %15
%292 = load float*, float** %10
%293 = getelementptr inbounds float, float* %292, i64 1
%294 = load float, float* %293
store float %294, float* %16
%295 = load float*, float** %10
%296 = getelementptr inbounds float, float* %295, i64 2
%297 = load float, float* %296
store float %297, float* %17
%298 = load float*, float** %10
%299 = getelementptr inbounds float, float* %298, i64 3
%300 = load float, float* %299
store float %300, float* %18
%301 = load float*, float** %8
%302 = getelementptr inbounds float, float* %301, i64 0
%303 = load float, float* %302
%304 = load float, float* %15
%305 = load float, float* %19
%306 = call float @llvm.fmuladd.f32(float %303, float %304, float %305)
store float %306, float* %19
%307 = load float*, float** %8
%308 = getelementptr inbounds float, float* %307, i64 1
%309 = load float, float* %308
%310 = load float, float* %15
%311 = load float, float* %20
%312 = call float @llvm.fmuladd.f32(float %309, float %310, float %311)
store float %312, float* %20
%313 = load float*, float** %8
%314 = getelementptr inbounds float, float* %313, i64 2
%315 = load float, float* %314
%316 = load float, float* %15
%317 = load float, float* %21
%318 = call float @llvm.fmuladd.f32(float %315, float %316, float %317)
store float %318, float* %21
%319 = load float*, float** %8
%320 = getelementptr inbounds float, float* %319, i64 3
%321 = load float, float* %320
%322 = load float, float* %15
%323 = load float, float* %22
%324 = call float @llvm.fmuladd.f32(float %321, float %322, float %323)
store float %324, float* %22
%325 = load float*, float** %9
%326 = getelementptr inbounds float, float* %325, i64 0
%327 = load float, float* %326
%328 = load float, float* %15
%329 = load float, float* %23
%330 = call float @llvm.fmuladd.f32(float %327, float %328, float %329)
store float %330, float* %23
%331 = load float*, float** %9
%332 = getelementptr inbounds float, float* %331, i64 1
%333 = load float, float* %332
%334 = load float, float* %15
%335 = load float, float* %24
%336 = call float @llvm.fmuladd.f32(float %333, float %334, float %335)
store float %336, float* %24
%337 = load float*, float** %9
%338 = getelementptr inbounds float, float* %337, i64 2
%339 = load float, float* %338
%340 = load float, float* %15
%341 = load float, float* %25
%342 = call float @llvm.fmuladd.f32(float %339, float %340, float %341)
store float %342, float* %25
%343 = load float*, float** %9
%344 = getelementptr inbounds float, float* %343, i64 3
%345 = load float, float* %344
%346 = load float, float* %15
%347 = load float, float* %26
%348 = call float @llvm.fmuladd.f32(float %345, float %346, float %347)
store float %348, float* %26
%349 = load float*, float** %8
%350 = getelementptr inbounds float, float* %349, i64 4
%351 = load float, float* %350
%352 = load float, float* %16
%353 = load float, float* %19
%354 = call float @llvm.fmuladd.f32(float %351, float %352, float %353)
store float %354, float* %19
%355 = load float*, float** %8
%356 = getelementptr inbounds float, float* %355, i64 5
%357 = load float, float* %356
%358 = load float, float* %16
%359 = load float, float* %20
%360 = call float @llvm.fmuladd.f32(float %357, float %358, float %359)
store float %360, float* %20
%361 = load float*, float** %8
%362 = getelementptr inbounds float, float* %361, i64 6
%363 = load float, float* %362
%364 = load float, float* %16
%365 = load float, float* %21
%366 = call float @llvm.fmuladd.f32(float %363, float %364, float %365)
store float %366, float* %21
%367 = load float*, float** %8
%368 = getelementptr inbounds float, float* %367, i64 7
%369 = load float, float* %368
%370 = load float, float* %16
%371 = load float, float* %22
%372 = call float @llvm.fmuladd.f32(float %369, float %370, float %371)
store float %372, float* %22
%373 = load float*, float** %9
%374 = getelementptr inbounds float, float* %373, i64 4
%375 = load float, float* %374
%376 = load float, float* %16
%377 = load float, float* %23
%378 = call float @llvm.fmuladd.f32(float %375, float %376, float %377)
store float %378, float* %23
%379 = load float*, float** %9
%380 = getelementptr inbounds float, float* %379, i64 5
%381 = load float, float* %380
%382 = load float, float* %16
%383 = load float, float* %24
%384 = call float @llvm.fmuladd.f32(float %381, float %382, float %383)
store float %384, float* %24
%385 = load float*, float** %9
%386 = getelementptr inbounds float, float* %385, i64 6
%387 = load float, float* %386
%388 = load float, float* %16
%389 = load float, float* %25
%390 = call float @llvm.fmuladd.f32(float %387, float %388, float %389)
store float %390, float* %25
%391 = load float*, float** %9
%392 = getelementptr inbounds float, float* %391, i64 7
%393 = load float, float* %392
%394 = load float, float* %16
%395 = load float, float* %26
%396 = call float @llvm.fmuladd.f32(float %393, float %394, float %395)
store float %396, float* %26
%397 = load float*, float** %8
%398 = getelementptr inbounds float, float* %397, i64 8
%399 = load float, float* %398
%400 = load float, float* %17
%401 = load float, float* %19
%402 = call float @llvm.fmuladd.f32(float %399, float %400, float %401)
store float %402, float* %19
%403 = load float*, float** %8
%404 = getelementptr inbounds float, float* %403, i64 9
%405 = load float, float* %404
%406 = load float, float* %17
%407 = load float, float* %20
%408 = call float @llvm.fmuladd.f32(float %405, float %406, float %407)
store float %408, float* %20
%409 = load float*, float** %8
%410 = getelementptr inbounds float, float* %409, i64 10
%411 = load float, float* %410
%412 = load float, float* %17
%413 = load float, float* %21
%414 = call float @llvm.fmuladd.f32(float %411, float %412, float %413)
store float %414, float* %21
%415 = load float*, float** %8
%416 = getelementptr inbounds float, float* %415, i64 11
%417 = load float, float* %416
%418 = load float, float* %17
%419 = load float, float* %22
%420 = call float @llvm.fmuladd.f32(float %417, float %418, float %419)
store float %420, float* %22
%421 = load float*, float** %9
%422 = getelementptr inbounds float, float* %421, i64 8
%423 = load float, float* %422
%424 = load float, float* %17
%425 = load float, float* %23
%426 = call float @llvm.fmuladd.f32(float %423, float %424, float %425)
store float %426, float* %23
%427 = load float*, float** %9
%428 = getelementptr inbounds float, float* %427, i64 9
%429 = load float, float* %428
%430 = load float, float* %17
%431 = load float, float* %24
%432 = call float @llvm.fmuladd.f32(float %429, float %430, float %431)
store float %432, float* %24
%433 = load float*, float** %9
%434 = getelementptr inbounds float, float* %433, i64 10
%435 = load float, float* %434
%436 = load float, float* %17
%437 = load float, float* %25
%438 = call float @llvm.fmuladd.f32(float %435, float %436, float %437)
store float %438, float* %25
%439 = load float*, float** %9
%440 = getelementptr inbounds float, float* %439, i64 11
%441 = load float, float* %440
%442 = load float, float* %17
%443 = load float, float* %26
%444 = call float @llvm.fmuladd.f32(float %441, float %442, float %443)
store float %444, float* %26
%445 = load float*, float** %8
%446 = getelementptr inbounds float, float* %445, i64 12
%447 = load float, float* %446
%448 = load float, float* %18
%449 = load float, float* %19
%450 = call float @llvm.fmuladd.f32(float %447, float %448, float %449)
store float %450, float* %19
%451 = load float*, float** %8
%452 = getelementptr inbounds float, float* %451, i64 13
%453 = load float, float* %452
%454 = load float, float* %18
%455 = load float, float* %20
%456 = call float @llvm.fmuladd.f32(float %453, float %454, float %455)
store float %456, float* %20
%457 = load float*, float** %8
%458 = getelementptr inbounds float, float* %457, i64 14
%459 = load float, float* %458
%460 = load float, float* %18
%461 = load float, float* %21
%462 = call float @llvm.fmuladd.f32(float %459, float %460, float %461)
store float %462, float* %21
%463 = load float*, float** %8
%464 = getelementptr inbounds float, float* %463, i64 15
%465 = load float, float* %464
%466 = load float, float* %18
%467 = load float, float* %22
%468 = call float @llvm.fmuladd.f32(float %465, float %466, float %467)
store float %468, float* %22
%469 = load float*, float** %9
%470 = getelementptr inbounds float, float* %469, i64 12
%471 = load float, float* %470
%472 = load float, float* %18
%473 = load float, float* %23
%474 = call float @llvm.fmuladd.f32(float %471, float %472, float %473)
store float %474, float* %23
%475 = load float*, float** %9
%476 = getelementptr inbounds float, float* %475, i64 13
%477 = load float, float* %476
%478 = load float, float* %18
%479 = load float, float* %24
%480 = call float @llvm.fmuladd.f32(float %477, float %478, float %479)
store float %480, float* %24
%481 = load float*, float** %9
%482 = getelementptr inbounds float, float* %481, i64 14
%483 = load float, float* %482
%484 = load float, float* %18
%485 = load float, float* %25
%486 = call float @llvm.fmuladd.f32(float %483, float %484, float %485)
store float %486, float* %25
%487 = load float*, float** %9
%488 = getelementptr inbounds float, float* %487, i64 15
%489 = load float, float* %488
%490 = load float, float* %18
%491 = load float, float* %26
%492 = call float @llvm.fmuladd.f32(float %489, float %490, float %491)
store float %492, float* %26
%493 = load float*, float** %8
%494 = getelementptr inbounds float, float* %493, i64 16
store float* %494, float** %8
%495 = load float*, float** %9
%496 = getelementptr inbounds float, float* %495, i64 16
store float* %496, float** %9
%497 = load float*, float** %10
%498 = getelementptr inbounds float, float* %497, i64 4
store float* %498, float** %10
br label %499
499: ; preds = %288
%500 = load i32, i32* %14
%501 = add nsw i32 %500, 4
store i32 %501, i32* %14
br label %283
502: ; preds = %283
br label %503
503: ; preds = %565, %502
%504 = load i32, i32* %14
%505 = load i32, i32* %7
%506 = icmp slt i32 %504, %505
br i1 %506, label %507, label %568
507: ; preds = %503
%508 = load float*, float** %10
%509 = getelementptr inbounds float, float* %508, i64 0
%510 = load float, float* %509
store float %510, float* %15
%511 = load float*, float** %8
%512 = getelementptr inbounds float, float* %511, i64 0
%513 = load float, float* %512
%514 = load float, float* %15
%515 = load float, float* %19
%516 = call float @llvm.fmuladd.f32(float %513, float %514, float %515)
store float %516, float* %19
%517 = load float*, float** %8
%518 = getelementptr inbounds float, float* %517, i64 1
%519 = load float, float* %518
%520 = load float, float* %15
%521 = load float, float* %20
%522 = call float @llvm.fmuladd.f32(float %519, float %520, float %521)
store float %522, float* %20
%523 = load float*, float** %8
%524 = getelementptr inbounds float, float* %523, i64 2
%525 = load float, float* %524
%526 = load float, float* %15
%527 = load float, float* %21
%528 = call float @llvm.fmuladd.f32(float %525, float %526, float %527)
store float %528, float* %21
%529 = load float*, float** %8
%530 = getelementptr inbounds float, float* %529, i64 3
%531 = load float, float* %530
%532 = load float, float* %15
%533 = load float, float* %22
%534 = call float @llvm.fmuladd.f32(float %531, float %532, float %533)
store float %534, float* %22
%535 = load float*, float** %9
%536 = getelementptr inbounds float, float* %535, i64 0
%537 = load float, float* %536
%538 = load float, float* %15
%539 = load float, float* %23
%540 = call float @llvm.fmuladd.f32(float %537, float %538, float %539)
store float %540, float* %23
%541 = load float*, float** %9
%542 = getelementptr inbounds float, float* %541, i64 1
%543 = load float, float* %542
%544 = load float, float* %15
%545 = load float, float* %24
%546 = call float @llvm.fmuladd.f32(float %543, float %544, float %545)
store float %546, float* %24
%547 = load float*, float** %9
%548 = getelementptr inbounds float, float* %547, i64 2
%549 = load float, float* %548
%550 = load float, float* %15
%551 = load float, float* %25
%552 = call float @llvm.fmuladd.f32(float %549, float %550, float %551)
store float %552, float* %25
%553 = load float*, float** %9
%554 = getelementptr inbounds float, float* %553, i64 3
%555 = load float, float* %554
%556 = load float, float* %15
%557 = load float, float* %26
%558 = call float @llvm.fmuladd.f32(float %555, float %556, float %557)
store float %558, float* %26
%559 = load float*, float** %8
%560 = getelementptr inbounds float, float* %559, i64 4
store float* %560, float** %8
%561 = load float*, float** %9
%562 = getelementptr inbounds float, float* %561, i64 4
store float* %562, float** %9
%563 = load float*, float** %10
%564 = getelementptr inbounds float, float* %563, i64 1
store float* %564, float** %10
br label %565
565: ; preds = %507
%566 = load i32, i32* %14
%567 = add nsw i32 %566, 1
store i32 %567, i32* %14
br label %503
568: ; preds = %503
%569 = load i32, i32* %12
%570 = icmp eq i32 %569, 0
br i1 %570, label %571, label %596
571: ; preds = %568
%572 = load float, float* %19
%573 = load float*, float** %11
%574 = getelementptr inbounds float, float* %573, i64 0
store float %572, float* %574
%575 = load float, float* %20
%576 = load float*, float** %11
%577 = getelementptr inbounds float, float* %576, i64 1
store float %575, float* %577
%578 = load float, float* %21
%579 = load float*, float** %11
%580 = getelementptr inbounds float, float* %579, i64 2
store float %578, float* %580
%581 = load float, float* %22
%582 = load float*, float** %11
%583 = getelementptr inbounds float, float* %582, i64 3
store float %581, float* %583
%584 = load float, float* %23
%585 = load float*, float** %11
%586 = getelementptr inbounds float, float* %585, i64 4
store float %584, float* %586
%587 = load float, float* %24
%588 = load float*, float** %11
%589 = getelementptr inbounds float, float* %588, i64 5
store float %587, float* %589
%590 = load float, float* %25
%591 = load float*, float** %11
%592 = getelementptr inbounds float, float* %591, i64 6
store float %590, float* %592
%593 = load float, float* %26
%594 = load float*, float** %11
%595 = getelementptr inbounds float, float* %594, i64 7
store float %593, float* %595
br label %682
596: ; preds = %568
%597 = load i32, i32* %12
%598 = icmp eq i32 %597, 1
br i1 %598, label %599, label %640
599: ; preds = %596
%600 = load float, float* %19
%601 = load float*, float** %11
%602 = getelementptr inbounds float, float* %601, i64 0
%603 = load float, float* %602
%604 = fadd float %603, %600
store float %604, float* %602
%605 = load float, float* %20
%606 = load float*, float** %11
%607 = getelementptr inbounds float, float* %606, i64 1
%608 = load float, float* %607
%609 = fadd float %608, %605
store float %609, float* %607
%610 = load float, float* %21
%611 = load float*, float** %11
%612 = getelementptr inbounds float, float* %611, i64 2
%613 = load float, float* %612
%614 = fadd float %613, %610
store float %614, float* %612
%615 = load float, float* %22
%616 = load float*, float** %11
%617 = getelementptr inbounds float, float* %616, i64 3
%618 = load float, float* %617
%619 = fadd float %618, %615
store float %619, float* %617
%620 = load float, float* %23
%621 = load float*, float** %11
%622 = getelementptr inbounds float, float* %621, i64 4
%623 = load float, float* %622
%624 = fadd float %623, %620
store float %624, float* %622
%625 = load float, float* %24
%626 = load float*, float** %11
%627 = getelementptr inbounds float, float* %626, i64 5
%628 = load float, float* %627
%629 = fadd float %628, %625
store float %629, float* %627
%630 = load float, float* %25
%631 = load float*, float** %11
%632 = getelementptr inbounds float, float* %631, i64 6
%633 = load float, float* %632
%634 = fadd float %633, %630
store float %634, float* %632
%635 = load float, float* %26
%636 = load float*, float** %11
%637 = getelementptr inbounds float, float* %636, i64 7
%638 = load float, float* %637
%639 = fadd float %638, %635
store float %639, float* %637
br label %681
640: ; preds = %596
%641 = load float, float* %19
%642 = load float*, float** %11
%643 = getelementptr inbounds float, float* %642, i64 0
%644 = load float, float* %643
%645 = fsub float %644, %641
store float %645, float* %643
%646 = load float, float* %20
%647 = load float*, float** %11
%648 = getelementptr inbounds float, float* %647, i64 1
%649 = load float, float* %648
%650 = fsub float %649, %646
store float %650, float* %648
%651 = load float, float* %21
%652 = load float*, float** %11
%653 = getelementptr inbounds float, float* %652, i64 2
%654 = load float, float* %653
%655 = fsub float %654, %651
store float %655, float* %653
%656 = load float, float* %22
%657 = load float*, float** %11
%658 = getelementptr inbounds float, float* %657, i64 3
%659 = load float, float* %658
%660 = fsub float %659, %656
store float %660, float* %658
%661 = load float, float* %23
%662 = load float*, float** %11
%663 = getelementptr inbounds float, float* %662, i64 4
%664 = load float, float* %663
%665 = fsub float %664, %661
store float %665, float* %663
%666 = load float, float* %24
%667 = load float*, float** %11
%668 = getelementptr inbounds float, float* %667, i64 5
%669 = load float, float* %668
%670 = fsub float %669, %666
store float %670, float* %668
%671 = load float, float* %25
%672 = load float*, float** %11
%673 = getelementptr inbounds float, float* %672, i64 6
%674 = load float, float* %673
%675 = fsub float %674, %671
store float %675, float* %673
%676 = load float, float* %26
%677 = load float*, float** %11
%678 = getelementptr inbounds float, float* %677, i64 7
%679 = load float, float* %678
%680 = fsub float %679, %676
store float %680, float* %678
br label %681
681: ; preds = %640, %599
br label %682
682: ; preds = %29, %681, %571
ret void
}

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