void kernel_strmv_u_n_8_lib8(int kmax, float *A0, float *x, float *y, int alg) {
  if (kmax <= 0)
    return;
  const int lda = 8;
  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;
  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 += A0[4 + 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 += A0[4 + lda * 1] * x_1;
  y_5 += A0[5 + 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 += A0[4 + lda * 2] * x_2;
  y_5 += A0[5 + lda * 2] * x_2;
  y_6 += A0[6 + 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 += A0[4 + lda * 3] * x_3;
  y_5 += A0[5 + lda * 3] * x_3;
  y_6 += A0[6 + lda * 3] * x_3;
  y_7 += A0[7 + lda * 3] * x_3;
  A0 += 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 += A0[4 + lda * 0] * x_0;
    y_5 += A0[5 + lda * 0] * x_0;
    y_6 += A0[6 + lda * 0] * x_0;
    y_7 += A0[7 + 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 += A0[4 + lda * 1] * x_1;
    y_5 += A0[5 + lda * 1] * x_1;
    y_6 += A0[6 + lda * 1] * x_1;
    y_7 += A0[7 + 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 += A0[4 + lda * 2] * x_2;
    y_5 += A0[5 + lda * 2] * x_2;
    y_6 += A0[6 + lda * 2] * x_2;
    y_7 += A0[7 + 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 += A0[4 + lda * 3] * x_3;
    y_5 += A0[5 + lda * 3] * x_3;
    y_6 += A0[6 + lda * 3] * x_3;
    y_7 += A0[7 + lda * 3] * x_3;
    A0 += 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 += A0[4 + lda * 0] * x_0;
    y_5 += A0[5 + lda * 0] * x_0;
    y_6 += A0[6 + lda * 0] * x_0;
    y_7 += A0[7 + lda * 0] * x_0;
    A0 += 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_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1126 <kernel_strmv_u_n_8_lib8+0x26>
jmp    1e24 <kernel_strmv_u_n_8_lib8+0xd24>
movl   $0x8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%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)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%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  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%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  0x6c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x30(%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  -0x30(%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  -0x34(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%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  0x4c(%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  0x50(%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  0x54(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%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  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%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  0x6c(%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  0x70(%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  0x74(%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  0x78(%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  0x7c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
movl   $0x8,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1b03 <kernel_strmv_u_n_8_lib8+0xa03>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x30(%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  -0x30(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x30(%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  -0x34(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x34(%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  -0x34(%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  -0x34(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%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  0x4c(%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  0x50(%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  0x54(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%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  0x5c(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%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  0x6c(%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  0x70(%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  0x74(%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  0x78(%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  0x7c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    1694 <kernel_strmv_u_n_8_lib8+0x594>
jmp    1b08 <kernel_strmv_u_n_8_lib8+0xa08>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c46 <kernel_strmv_u_n_8_lib8+0xb46>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x30(%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  -0x30(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b08 <kernel_strmv_u_n_8_lib8+0xa08>
cmpl   $0x0,-0x24(%rbp)
jne    1cc4 <kernel_strmv_u_n_8_lib8+0xbc4>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    1e24 <kernel_strmv_u_n_8_lib8+0xd24>
cmpl   $0x1,-0x24(%rbp)
jne    1d69 <kernel_strmv_u_n_8_lib8+0xc69>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x10(%rax),%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x14(%rax),%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x18(%rax),%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x1c(%rax),%xmm0
movss  %xmm0,0x1c(%rax)
jmp    1e1f <kernel_strmv_u_n_8_lib8+0xd1f>
movss  -0x40(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x54(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x58(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x5c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
jmp    1e24 <kernel_strmv_u_n_8_lib8+0xd24>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strmv_u_n_8_lib8>:
test   %edi,%edi
jle    13fe <kernel_strmv_u_n_8_lib8+0x2fe>
movss  0x4(%rdx),%xmm1
movss  0x8(%rdx),%xmm3
movss  (%rsi),%xmm2
mulss  (%rdx),%xmm2
xorps  %xmm0,%xmm0
addss  %xmm0,%xmm2
movss  0x20(%rsi),%xmm4
mulss  %xmm1,%xmm4
mulss  0x24(%rsi),%xmm1
addss  %xmm2,%xmm4
addss  %xmm0,%xmm1
movss  0x40(%rsi),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
movsd  0x44(%rsi),%xmm2
unpcklps %xmm3,%xmm3
mulps  %xmm2,%xmm3
xorps  %xmm2,%xmm2
xorps  %xmm4,%xmm4
movss  %xmm1,%xmm4
addps  %xmm3,%xmm4
movups 0x60(%rsi),%xmm1
movss  0xc(%rdx),%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(%rdx),%xmm4
movss  0x14(%rdx),%xmm1
movss  0x18(%rdx),%xmm3
movups 0x80(%rsi),%xmm5
movaps %xmm4,%xmm7
shufps $0x0,%xmm4,%xmm7
mulps  %xmm5,%xmm7
addps  %xmm6,%xmm7
mulss  0x90(%rsi),%xmm4
addss  %xmm0,%xmm4
movups 0xa0(%rsi),%xmm5
movaps %xmm1,%xmm6
shufps $0x0,%xmm1,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm7,%xmm6
movss  0xb0(%rsi),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  0xb4(%rsi),%xmm1
addss  %xmm0,%xmm1
movups 0xc0(%rsi),%xmm4
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
mulps  %xmm0,%xmm4
addps  %xmm6,%xmm4
mulss  0xd0(%rsi),%xmm3
addss  %xmm5,%xmm3
movsd  0xd4(%rsi),%xmm5
xorps  %xmm6,%xmm6
movss  %xmm1,%xmm6
mulps  %xmm0,%xmm5
addps  %xmm6,%xmm5
movups 0xe0(%rsi),%xmm0
movss  0x1c(%rdx),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm6,%xmm0
addps  %xmm4,%xmm0
movups 0xf0(%rsi),%xmm1
movss  %xmm3,%xmm2
shufps $0x4c,%xmm5,%xmm2
shufps $0x78,%xmm2,%xmm2
mulps  %xmm6,%xmm1
addps  %xmm2,%xmm1
add    $0x100,%rsi
add    $0x20,%rdx
mov    $0x8,%eax
cmp    $0xc,%edi
jb     1313 <kernel_strmv_u_n_8_lib8+0x213>
lea    -0x3(%rdi),%r9d
mov    $0x8,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rsi),%xmm2
movups 0x10(%rsi),%xmm5
movups 0x20(%rsi),%xmm6
movups 0x30(%rsi),%xmm8
movss  (%rdx),%xmm7
movss  0x4(%rdx),%xmm4
movss  0x8(%rdx),%xmm3
movss  0xc(%rdx),%xmm9
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm2
addps  %xmm0,%xmm2
mulps  %xmm5,%xmm7
addps  %xmm1,%xmm7
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm6
addps  %xmm2,%xmm6
mulps  %xmm8,%xmm4
addps  %xmm7,%xmm4
movups 0x40(%rsi),%xmm2
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm2
addps  %xmm6,%xmm2
movups 0x50(%rsi),%xmm5
mulps  %xmm3,%xmm5
addps  %xmm4,%xmm5
movups 0x60(%rsi),%xmm4
shufps $0x0,%xmm9,%xmm9
mulps  %xmm9,%xmm4
movaps %xmm4,%xmm0
addps  %xmm2,%xmm0
movups 0x70(%rsi),%xmm6
mulps  %xmm9,%xmm6
movaps %xmm6,%xmm1
addps  %xmm5,%xmm1
sub    $0xffffffffffffff80,%rsi
add    $0x10,%rdx
add    $0x4,%eax
cmp    %r9d,%eax
jl     1270 <kernel_strmv_u_n_8_lib8+0x170>
addps  %xmm5,%xmm6
addps  %xmm2,%xmm4
mov    %edi,%eax
and    $0xfffffffc,%eax
movaps %xmm4,%xmm0
movaps %xmm6,%xmm1
cmp    %edi,%eax
jge    132d <kernel_strmv_u_n_8_lib8+0x22d>
mov    %eax,%r9d
not    %r9d
test   $0x1,%dil
jne    1338 <kernel_strmv_u_n_8_lib8+0x238>
add    %edi,%r9d
jne    1369 <kernel_strmv_u_n_8_lib8+0x269>
jmp    13c2 <kernel_strmv_u_n_8_lib8+0x2c2>
movaps %xmm0,%xmm3
movaps %xmm1,%xmm2
jmp    13c2 <kernel_strmv_u_n_8_lib8+0x2c2>
movss  (%rdx),%xmm4
shufps $0x0,%xmm4,%xmm4
movups (%rsi),%xmm3
movups 0x10(%rsi),%xmm2
mulps  %xmm4,%xmm3
addps  %xmm0,%xmm3
mulps  %xmm4,%xmm2
addps  %xmm1,%xmm2
add    $0x20,%rsi
add    $0x4,%rdx
or     $0x1,%eax
movaps %xmm3,%xmm0
movaps %xmm2,%xmm1
add    %edi,%r9d
je     13c2 <kernel_strmv_u_n_8_lib8+0x2c2>
sub    %eax,%edi
xor    %eax,%eax
nopl   (%rax)
movss  (%rdx,%rax,4),%xmm6
movss  0x4(%rdx,%rax,4),%xmm2
shufps $0x0,%xmm6,%xmm6
movups (%rsi),%xmm4
movups 0x10(%rsi),%xmm5
movups 0x20(%rsi),%xmm3
movups 0x30(%rsi),%xmm7
mulps  %xmm6,%xmm4
addps  %xmm0,%xmm4
mulps  %xmm6,%xmm5
addps  %xmm1,%xmm5
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm3
movaps %xmm3,%xmm0
addps  %xmm4,%xmm0
mulps  %xmm7,%xmm2
movaps %xmm2,%xmm1
addps  %xmm5,%xmm1
add    $0x2,%rax
add    $0x40,%rsi
cmp    %eax,%edi
jne    1370 <kernel_strmv_u_n_8_lib8+0x270>
addps  %xmm5,%xmm2
addps  %xmm4,%xmm3
cmp    $0x1,%r8d
je     13d5 <kernel_strmv_u_n_8_lib8+0x2d5>
test   %r8d,%r8d
jne    13ea <kernel_strmv_u_n_8_lib8+0x2ea>
movups %xmm3,(%rcx)
movups %xmm2,0x10(%rcx)
ret
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
addps  %xmm0,%xmm3
movups %xmm3,(%rcx)
addps  %xmm1,%xmm2
movups %xmm2,0x10(%rcx)
ret
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
subps  %xmm3,%xmm0
movups %xmm0,(%rcx)
subps  %xmm2,%xmm1
movups %xmm1,0x10(%rcx)
ret

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

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